Home

RogueRig134

May 13, 2025

Article

@ikadotxyz, the ultra-fast parallel MPC network on the Sui blockchain, is generating serious buzz for its potential to revolutionize Web3 security and interoperability. Recent posts on X highlight the bullish sentiment, with IKA reportedly trading between $4.90 and $10 on pre-market platforms like Whales, despite a 1B token supply. This suggests a possible market cap in the billions if the momentum holds, fueled by a $21M strategic investment from the Sui Foundation and a record-setting 1.4M SUI NFT art campaign. Ika’s sub-second latency and ability to scale across hundreds of signer nodes make it a game-changer for DeFi, decentralized custody, and cross-chain applications. The upcoming IKA token launch on Sui is expected to unlock new utility, driving further adoption. X users are hyped about IKA’s role in the @GiveRep loyalty program, with some calling it one of the biggest airdrop opportunities on Sui. That said, pre-market prices can be volatile and speculative, so the $4.90–$10 range isn’t guaranteed to hold post-launch. Always dig into the project’s fundamentals—check Ika’s official channels for deeper insights—and weigh the risks before jumping in. The Sui ecosystem is heating up, but nothing’s a sure bet in crypto

Rogue129

May 13, 2025

Article

To set up a Sui node, you'll need to install the Sui binaries, clone the Sui repository, and configure the node. You can either build from source or use Docker. Once the node is running, you can monitor its status and sync progress. Detailed Steps: Install Sui Binaries: Follow the instructions in the Sui Documentation to install the Sui binaries. If you're using Docker, follow the instructions in the Sui Full node Docker Readme. If you're building from source, you'll need to clone the Sui repository and compile it. Configure the Node: Full Node: You can configure a Sui Full node using Docker or by building from source, according to the Sui Documentation. Validator Node: Follow the instructions in the Sui Validator Node Configuration to configure a validator node. This includes installing and configuring Sui, key management, and storage configuration. Full node configuration: Shut down any running Full node. Remove the database and genesis.blob file. Fetch the source from the latest release. Reset your branch. Download the latest genesis blob. Update your fullnode.yaml configuration file, if needed. Restart your Sui Full node. Run the Node: Start the Sui node using the appropriate command for your configuration method (e.g., sui-node or Docker commands). Monitor the Node: Monitor your node's status, sync progress, and logs to ensure it's running correctly. Use tools like logging, tracing, and metrics to monitor the node. The default metrics port is 9184, but you can change it in the fullnode.yaml file. Additional Steps: Committee registration: If you're running a validator node, you'll need to register with the committee. Liquid staking: If you're running a node, you can also participate in liquid staking. Sync your fork: If you're contributing to the Sui project, you'll need to sync your fork with the main repository. By following these steps, you can successfully set up and run a Sui node.

HaGiang134

May 12, 2025

Article

In the exploration of the Web3 world, beyond the common pursuit of faster transaction speeds and lower fees, deeper, structural challenges are increasingly surfacing. How can massive amounts of data be stored economically? How can sensitive information be securely protected in a decentralized environment? Can complex computations be efficiently executed off-chain while still having their results verified and trusted on-chain? Many projects attempt to address these problems by combining various third-party services. However, this path often brings with it integration complexity, potential trust friction, and a fragmented user experience. Facing these infrastructure-level challenges, the Sui blockchain and its core development team Mysten Labs have proposed a more integrated solution. Rather than relying on a patchwork of external tools, they’ve designed a blockchain with a unique architecture—including its object-centric model and the Move programming language while simultaneously building three tightly connected native infrastructure components: Walrus, Seal, and Nautilus. This article aims to unpack the design concepts behind these three components, explore how they work, how they relate to each other, and what real changes they might bring to Web3 applications. Sui’s Unique Architecture To understand how these three tools operate on Sui, we must first look at some key characteristics of the Sui platform itself. One of Sui’s core innovations is its object-oriented model, a fundamental shift from the traditional account-based architecture. Sui treats tokens, NFTs, and even complex data structures as standalone “objects”. Imagine managing each asset as a separate box instead of logging everything into a single ledger. This design allows unrelated actions—like handling two unrelated NFTs—to be processed in parallel, enhancing throughput. This object granularity creates a natural synergy with Walrus and Seal: Walrus treats stored data as objects, while Seal can attach permission rules directly to individual objects. In addition, Sui uses the Move programming language, designed specifically for managing digital assets. Move emphasizes safety and aims to reduce many common smart contract vulnerabilities at the language level. This strong foundation makes it well-suited for building robust infrastructure components. By aligning chain design and infrastructure development under one roof (Mysten Labs), Sui aims to deliver a more seamless, synergistic developer experience. ⸻ Walrus: Economical, Programmable Decentralized Storage Storing large files (images, videos, AI models—collectively called blobs) directly on-chain is notoriously expensive. Existing decentralized storage solutions each have trade-offs, but Walrus seeks a new balance between cost-efficiency and smart contract interactivity, directly tackling the cost barriers of large-scale on-chain data. At the heart of Walrus is Erasure Coding, a clever technique that “shards” a file and adds “recovery clues” so the file can be reconstructed even if parts are lost. Walrus calls these extra fragments “Red Stuff”. Think of it this way: if you have two numbers, say 3 and 5, and you store both as well as their sum (8), losing the 3 isn’t catastrophic—you can recover it using 8 - 5 = 3. The additional recovery fragments play a similar role, mathematically tied to the originals. After fragmenting and encoding, Walrus distributes these shards across many nodes. Even if some shards go missing, the system can reconstruct the original file as long as a threshold number of fragments is retrieved—saving significant space compared to full file replication. This approach dramatically reduces storage costs and could bring decentralized storage pricing closer to that of centralized cloud providers. Even more interesting, Walrus leverages Sui’s object model: each stored file becomes a programmable on-chain object. Developers can use Move to write smart contracts that manage these storage objects—setting access rules, auto-updating metadata, etc. Storage is no longer just passive—it becomes a natively programmable resource. There’s also a token utility layer: interacting with Walrus data on Sui requires SUI tokens to record metadata (like file names, sizes, storage locations) and potentially lock tokens for storage fees. If Walrus adoption grows, demand for SUI could increase, tightening supply. ⸻ Seal: The Decentralized Vault and Access Gatekeeper Many Web3 apps deal with sensitive data: user IDs, financial details, paywalled content. In a decentralized context, how do you securely store secrets and control access to them? Seal is a Decentralized Secrets Management (DSM) solution designed to answer that question. One of its core technologies is Threshold Encryption. Imagine a vault that requires two keys to open, each held by a different person. Similarly, threshold encryption splits decryption keys into multiple parts and distributes them to independent key servers. Only when a predefined number of them collaborate (the threshold) can the data be decrypted—no single server can do it alone, which spreads out trust and increases fault tolerance. Seal’s other clever feature is that access control logic is written as Move smart contracts on-chain. Developers can define clear rules: for example, only users holding a certain NFT or who’ve paid a fee can access certain data. This transparency and verifiability distinguishes Seal from traditional centralized access systems. When a user or app wants to decrypt a secret, it sends a request to key servers. These servers check the on-chain rules. Only if conditions are met do they release their key fragments. The actual decryption happens on the client device, so key servers never touch the original data. Seal can protect data stored anywhere—on Walrus, other decentralized networks, or even centralized clouds. This makes it ideal for secure messaging, private user data, paid content gating, confidential voting, and more. ⸻ Nautilus: Making Off-Chain Computation Verifiable On-Chain Blockchains aren’t great at complex or resource-heavy tasks. Doing those on-chain is slow, expensive, and compromises privacy. Solutions like Layer 2s or oracles help, but Nautilus explores a different path: enabling trustworthy off-chain computation. Nautilus uses a hardware-based solution called Trusted Execution Environments (TEEs). Think of a TEE as a secure, isolated zone inside a CPU. Code and data inside this zone are shielded from the rest of the system, including the operating system itself. The basic workflow is as follows: A developer deploys a computational task (e.g., financial models, AI inference, game logic) to a TEE they control. When the task finishes, the TEE produces a cryptographic attestation—a kind of tamper-proof “receipt” that proves: the task ran in a TEE the code wasn’t tampered with the process completed successfully. This attestation and the result are submitted to a Move smart contract on Sui. The contract verifies the attestation (e.g., signature validity and hash of the code). Only if verification passes does the contract accept the result and proceed with on-chain actions. Nautilus bridges high-performance off-chain computing with on-chain verifiability and trust, without exposing sensitive details. ⸻ Nautilus in Action: The Case of Bluefin A concrete example is Bluefin, a decentralized perpetuals trading platform. Most high-performance trading platforms face a dilemma: keeping order books fully on-chain offers transparency but is slow and expensive; moving them off-chain improves speed but introduces trust issues. Bluefin uses Nautilus to bridge this gap: • Order matching runs inside a TEE, ensuring secure, isolated processing. • Nautilus provides cryptographic proof that the matching logic ran correctly. • Proofs and results are submitted on-chain, where smart contracts verify them before executing settlement. This approach allows Bluefin to offer fast off-chain matching with on-chain trust guarantees, making it viable for performance-heavy DeFi like derivatives trading. Of course, this does shift some trust from pure blockchain consensus to TEE hardware and implementation.

HaGiang134

May 01, 2025

Article

What is Sui’s Kiosk? Kiosk is a native smart contract module on the Sui blockchain, designed to standardize and simplify the way NFTs are stored, managed, and traded. It acts as a programmable NFT storefront—ideal for devs who want to avoid reinventing the wheel for every NFT-related project. Whether you’re building a marketplace, a game asset exchange, or a digital collectibles gallery, Kiosk offers you secure, customizable building blocks. ⸻ 🛠️ Key Features of Kiosk 📦 NFT Storage & Display: Users can deposit NFTs into Kiosk smart contracts to store, show off, or trade them 🔐 Secure Ownership Transfer: All buy/sell flows are standardized and verifiable—goodbye shady swaps 👋 🎛️ Fine-grained Permissions: Kiosk lets devs define exactly who can do what with each NFT. 📈 Developer Extensibility: Plug in auctions, batch listings, bundles, and more. ⸻ 🤔 Why Build with Kiosk? Imagine you’re launching an NFT app. You’ll likely need a way for users to store assets safely. A way to list and buy assets. Kiosk handles all that for you. Instead of writing all these flows from scratch (and risking bugs 🐛 or exploits), you use Kiosk’s battle-tested API. ⸻ 🧪 Example App: Building with Kiosk Let’s get into a real example. You’ll create a basic NFT module, then use the Kiosk module to deposit it, list it, and allow others to purchase it. Step-by-Step Code Breakdown module 0xNFT::simple_nft { use sui::object::{UID}; use sui::tx_context::TxContext; struct SimpleNFT has key { id: UID, name: String, description: String, url: String, } public entry fun mint( name: String, description: String, url: String, ctx: &mut TxContext ): SimpleNFT { SimpleNFT { id: UID::new(ctx), name, description, url, } } } Commands (Sui CLI) Compile your package sui move build Deploy to network sui client publish --gas-budget 10000 Mint NFT sui client call --function mint --module simple_nft \ --args "My NFT" "Desc" "https://example.com/img.png" --gas-budget 1000 Initialize Kiosk sui client call --function init_kiosk --module kiosk_example --gas-budget 1000 Deposit NFT to Kiosk sui client call --function deposit_nft --module kiosk_example \ --args --gas-budget 1000 List for sale sui client call --function list_nft_for_sale --module kiosk_example \ --args 100 --gas-budget 1000 Purchase NFT sui client call --function purchase_nft --module kiosk_example \ --args --gas-budget 1000 Kiosk is one of the most powerful primitives in the Sui ecosystem for NFT developers. It abstracts away repetitive logic and injects security and modularity into your app stack. With just a few lines of code, you’re building full NFT marketplace flows that are production-ready and battle-tested.

MiniBob380

Apr 30, 2025

Article

In the ever-evolving landscape of blockchain technology, smart contract programming languages have become the backbone of decentralized applications (dApps). Among these, Move has emerged as a groundbreaking innovation, offering unique features that set it apart from traditional languages like Solidity or Vyper. Designed with security and scalability in mind, Move was created to address many of the vulnerabilities and inefficiencies inherent in earlier blockchain ecosystems. This article delves into the origins, features, and impact of the Move programming language, exploring its journey from inception to becoming one of the most promising tools for building robust decentralized systems. The Origins of Move: A Solution to Blockchain Challenges The Move programming language was first introduced by Meta (formerly Facebook) as part of its ambitious Diem project (initially called Libra). Diem aimed to create a global digital currency and financial infrastructure powered by blockchain technology. However, the team quickly realized that existing smart contract languages were insufficient for their vision. Traditional languages often lacked mechanisms to prevent common vulnerabilities such as reentrancy attacks, integer overflows, and unauthorized asset duplication. These issues had already caused significant damage in other ecosystems, most notably the infamous DAO hack on Ethereum. To overcome these challenges, Meta’s engineering team developed Move, a new language specifically designed for resource-oriented programming. Unlike conventional programming languages, Move treats digital assets as first-class resources , ensuring they cannot be duplicated, unintentionally deleted, or misused. This approach was inspired by linear logic, a mathematical framework that enforces strict ownership rules for resources. By embedding these principles into the core of the language, Move introduced a paradigm shift in how developers interact with digital assets on the blockchain. Although the Diem project was eventually shelved due to regulatory scrutiny, Move found new life in independent blockchain projects like Aptos and Sui. These platforms adopted Move as their primary smart contract language, recognizing its potential to revolutionize the way decentralized applications are built and secured. Key Features of Move: Why It Stands Out 1. Resource-Oriented Programming One of Move’s defining characteristics is its focus on resource-oriented programming . In Move, digital assets such as tokens, NFTs, or even custom objects are treated as resources that follow strict ownership rules. Once created, a resource cannot be copied or destroyed unless explicitly allowed by its module. This ensures that critical operations involving assets—such as transfers or state updates—are performed safely and securely. For example, consider a simple token transfer function written in Move: module examples::token { use sui::object::{Self, UID}; use sui::transfer; struct Token has key, store { id: UID, value: u64, } public fun mint(ctx: &mut TxContext, value: u64): Token { Token { id: object::new(ctx), value, } } public fun transfer_token(token: Token, recipient: address) { transfer::public_transfer(token, recipient); } } Here, the Token struct represents a resource that can only be transferred using the public_transfer function. Any attempt to duplicate or manipulate the token outside this function would result in a compilation error. This design eliminates entire classes of bugs and exploits commonly seen in other languages. 2. Modularity and Encapsulation Move promotes modular design , allowing developers to encapsulate functionality within self-contained modules. Each module defines its own types, functions, and access controls, ensuring clear separation between different components of a smart contract. For instance, a developer might create separate modules for token creation, trading pairs, and governance logic. This modularity enhances code readability, maintainability, and reusability. 3. Formal Verification Support Another standout feature of Move is its support for formal verification , a process used to mathematically prove the correctness of a program. Formal verification helps identify subtle bugs and edge cases that may not be caught through traditional testing methods. While not all Move-based projects require formal verification, the language’s structure makes it easier to apply this technique when needed. 4. Object-Centric Design (Sui-Specific Enhancements) On the Sui blockchain , Move has been further enhanced with an object-centric model . Every resource in Sui Move has a globally unique identifier (UID), enabling direct referencing and interaction with objects. This design simplifies complex workflows, such as managing NFTs or tracking user-specific data, while maintaining high performance and scalability. Real-World Applications of Move Since its adoption by Aptos and Sui, Move has been used to build a wide range of decentralized applications. Some notable examples include: 1. Decentralized Finance (DeFi) Protocols Move’s strong emphasis on security makes it ideal for DeFi applications, where billions of dollars worth of assets are at stake. Projects like Cetus —a decentralized exchange (DEX) built on Sui—leverage Move’s resource-oriented programming to implement advanced trading features while minimizing risks associated with asset manipulation. 2. Non-Fungible Tokens (NFTs) NFT marketplaces benefit greatly from Move’s ability to define and manage unique digital assets. Developers can create sophisticated NFT standards with granular control over ownership, royalties, and metadata. Additionally, Sui’s object-centric enhancements allow for seamless integration of dynamic NFTs, which can evolve based on predefined conditions. 3. Gaming and Metaverse Platforms Blockchain gaming requires efficient handling of in-game assets, player interactions, and real-time updates. Move’s modular architecture and low-latency execution make it well-suited for building immersive gaming experiences. Platforms like Blockus , a Web3 gaming ecosystem, utilize Move to power their decentralized games and economies. Comparing Move to Other Smart Contract Languages While Move shares some similarities with other smart contract languages, its unique features give it a competitive edge: Solidity : As Ethereum’s primary language, Solidity is widely adopted but suffers from legacy issues like vulnerability to reentrancy attacks. Move addresses these weaknesses through its resource-oriented model and stricter type safety. Rust (used in Solana) : Rust offers excellent performance and memory safety but lacks Move’s native support for resource management and formal verification. Additionally, Rust’s steep learning curve can deter newcomers compared to Move’s more intuitive syntax. Clarity (used in Stacks) : Clarity emphasizes transparency and predictability but operates within a limited scope tied to Bitcoin’s ecosystem. Move, on the other hand, supports broader use cases across multiple blockchains. The Future of Move: Adoption and Evolution As blockchain technology continues to mature, the demand for secure and scalable smart contract languages will only grow. Move is poised to play a pivotal role in shaping the next generation of decentralized applications, thanks to its innovative design and growing community support. Projects like Aptos and Sui are actively investing in developer education, tooling, and infrastructure to accelerate Move’s adoption. Initiatives such as the Move eLearning platform provide comprehensive tutorials and resources for aspiring developers, lowering the barrier to entry. Furthermore, collaborations with academic institutions and industry leaders are driving research into advanced topics like formal verification and cross-chain interoperability. Looking ahead, we can expect Move to expand beyond its current use cases, powering everything from enterprise-grade supply chain solutions to decentralized social networks. Its adaptability and robustness ensure that it remains relevant in an increasingly diverse and interconnected blockchain ecosystem.

harry phan381

Apr 30, 2025

Article

Hey “I know something, but I won’t tell you what and yet you’ll still believe me.”✨ Imagine this: You prove you work at a certain company. ✅ Without revealing your email. ✅ Without doxxing your Web2 identity. ✅ Fully verifiable on-chain. That’s the power of zero-knowledge proofs (zk proofs) and you don’t need a PhD in cryptography to start building with them anymore. Welcome to the world of zkApps: applications powered by cryptographic magic, but crafted with tools that feel just like writing regular code. What is a zkApp (zero-knowledge app)? A zkApp is an app where users can prove something about their private data without revealing the data itself. Think of it as flexing receipts… without showing your wallet. These apps enable functionality we often only dream about—like verifying someone’s identity without revealing their name, or allowing users to vote on-chain without revealing their actual vote. In the Sui ecosystem, zkApps take on an extra layer of potential. They bridge your off-chain secrets with on-chain logic, using tools like SP1 zkVM and Soundness Layer to make proof generation and verification more practical than ever. Traditionally, writing a zk circuit required cryptographic expertise and weeks of effort. But zkVMs like SP1, Risc0, and Nexus have flipped the game. These virtual machines allow developers to express their logic in normal programming languages, generate a zk proof for the result, and submit it for on-chain verification. This abstraction doesn’t just speed up development, it expands who can build zkApps. If you can write logic in Rust, you can build a zkApp. And if you use Soundness Layer, you can verify it on Sui. zkDomain: Proving Email Ownership Without Exposure Let’s consider a common scenario that a DAO wants to airdrop tokens to employees of a specific company. But instead of collecting user emails and verifying them manually, which exposes Web2 identity and risks user privacy, we want users to prove they own an email at @soundness.xyz, without ever revealing the full address. This is where the real-world magic of zk comes in. If you have access to a company email that uses Google Workspace, you can authenticate via OpenID Connect (OIDC) and receive a signed JWT (JSON Web Token) from Google. This token contains metadata, including your email. Now, instead of sending that JWT to the DAO, you generate a zk proof that says, “I have a valid Google-issued JWT, and my email ends with @soundness.xyz.” That proof is verified on-chain. No one ever sees your actual email. The DAO only sees that a proof has passed. Access granted. All the verification logic JWT parsing, signature validation, domain checking is run inside a zkVM program written in Rust, compiled by SP1. You can peek into the full implementation here: 👉 SP1 zkDomain Example #![no_main] sp1_zkvm::entrypoint!(main); use lib::{split_email, split_jwt, pem_to_der}; use rsa::{pkcs8::DecodePublicKey, Pkcs1v15Sign, RsaPublicKey}; use sha2_v0_10_8::{Digest, Sha256}; pub fn main() { // Read input values: JWT token, RSA public key, and the expected domain let token = sp1_zkvm::io::read::(); let rsa_public_key = sp1_zkvm::io::read::(); let domain = sp1_zkvm::io::read::(); // Commit the domain to the zk proof (so it’s publicly known) sp1_zkvm::io::commit(&domain); // Split the JWT into its components: header, payload, and signature let (header, payload, signature) = split_jwt(&token) .expect("Failed to decode JWT"); // Panic if JWT parsing fails // Convert the PEM public key into DER format for RSA verification let pk_der = pem_to_der(&rsa_public_key); let public_key = RsaPublicKey::from_public_key_der(&pk_der).unwrap(); // Reconstruct the signing input (header + payload) as a string let signing_input = format!( "{}.{}", token.split('.').collect::>()[0], // First part: header token.split('.').collect::>()[1] // Second part: payload ); // Hash the signing input using SHA256 let mut hasher = Sha256::new(); hasher.update(signing_input); let hashed_msg = hasher.finalize(); // Verify the JWT signature using the provided RSA public key let verification_result = match public_key.verify(Pkcs1v15Sign::new::(), &hashed_msg, &signature) { Ok(_) => true, // Signature is valid Err(_) => false, // Signature is invalid }; // Commit the verification result (proof that the JWT is authentic) sp1_zkvm::io::commit(&verification_result); // Extract and split the email address from the JWT payload let email_parts = split_email(payload.get("email").unwrap().to_string()).unwrap(); // Check if the email domain matches the expected domain let verified = email_parts.domain == domain; // Commit the verification result (proof that the email domain is correct) sp1_zkvm::io::commit(&verified); } Only the domain, and whether or not the JWT was valid. That’s it. The user’s full email, original JWT, and any other personally identifiable information stays hidden, cryptographically sealed inside the proof. Onchain Verification: From zkVM to Move Of course, generating the proof is just one side of the coin. The real utility kicks in when you can verify that proof on-chain—and take action based on it. Here’s where the Soundness Layer becomes a game-changer. Built for Sui, it acts as a zk verification layer that can process SP1-generated proofs—converted into Groth16 format, which Sui natively supports. You don’t need to mess with cryptographic primitives. You just write a smart contract in Move, pass the proof and the public inputs (like the expected domain), and let the verifier logic do the rest. This means your DAO smart contract can now gate airdrops based on email domain ownership—without ever touching sensitive data. Soundness Layer handles the verification. Your smart contract handles the logic. The rest is magic. Learn more about Soundness Layer here: 🔗 soundness.xyz/blog/soundness-layer You can build authentication flows without passwords. You can design voting systems that guarantee anonymity. You can gate access to DAOs, events, or rewards based on criteria that remain completely private. And crucially, you can do all of this using Rust + Sui + SP1 + Soundness Layer—without writing a single cryptographic constraint by hand. We’re no longer talking about theoretical zk. We’re talking about zk you can ship. Because privacy isn’t just a feature, it’s a foundation. And with zk, it’s finally composable.

MiniBob380

Apr 30, 2025

Article

Course #2: Deep Dive into Move Programming – Building Complex dApps on Sui Now that you’ve grasped the basics of Move programming and deployed your first smart contract, it’s time to take your skills to the next level. In this article, we’ll explore how to build more complex decentralized applications (dApps) using Move on the Sui blockchain. Step 1: Mastering Advanced Sui Move Concepts Before diving into coding, let’s revisit some advanced features of Move that make it uniquely suited for building secure and scalable dApps: 1. Resource-Oriented Programming Move treats digital assets as resources, ensuring they cannot be duplicated, unintentionally deleted, or misused (https://docs.sui.io/learn/resource-oriented-programming). This is achieved through strict ownership rules and type safety. For example: module examples::token { use sui::object::{Self, UID}; use sui::transfer; struct Token has key, store { id: UID, value: u64, } public fun mint(ctx: &mut TxContext, value: u64): Token { Token { id: object::new(ctx), value, } } public fun transfer_token(token: Token, recipient: address) { transfer::public_transfer(token, recipient); } } In this example, the Token resource is created and transferred securely. Resources in Move are immutable by default unless explicitly marked as mutable, adding an extra layer of security. 2. Modules and Encapsulation Modules in Move act as self-contained units of functionality, enabling better organization and reusability. For instance, you can separate token creation logic from transfer logic into distinct modules (https://examples.sui.io/modules). This modularity ensures cleaner code and easier maintenance. 3. Object-Centric Design Sui Move introduces an object-centric model, where every resource has a globally unique identifier (UID). This allows for direct referencing and interaction with objects, making it easier to manage complex state transitions (https://docs.sui.io/objects). Step 2: Writing a Modular Smart Contract Let’s create a more advanced smart contract that demonstrates these concepts. We’ll build a simple NFT marketplace where users can mint and trade NFTs. Define the NFT Resource Start by defining an NFT resource within a Move module: module examples::nft_marketplace { use sui::object::{Self, UID}; use sui::transfer; struct NFT has key, store { id: UID, name: String, price: u64, } public fun mint_nft(ctx: &mut TxContext, name: String, price: u64): NFT { NFT { id: object::new(ctx), name, price, } } public fun list_for_sale(nft: NFT, price: u64, ctx: &mut TxContext) { nft.price = price; transfer::public_transfer(nft, tx_context::sender(ctx)); } } Here, the NFT resource includes properties like name and price. The mint_nft function creates a new NFT, while list_for_sale allows users to list their NFTs for sale. Compile and Deploy Use the Sui CLI to compile and deploy your contract. Write a deployment script to automate this process: sui move build sui client publish --gas-budget 10000 This will package and deploy your module to the Sui Devnet (https://docs.sui.io/cli). Step 3: Building a React Frontend for Your Marketplace With your smart contract deployed, let’s connect it to a React frontend. Set Up the Project Initialize a React project if you haven’t already: npx create-react-app nft-marketplace cd nft-marketplace npm install @mysten/sui.js Integrate with Sui Wallet Use the @mysten/sui.js library to interact with the Sui blockchain: import { JsonRpcProvider, SuiClient } from '@mysten/sui.js'; const provider = new SuiClient({ url: 'https://fullnode.devnet.sui.io' }); async function fetchNFTs(ownerAddress) { const objects = await provider.getObjectsOwnedByAddress(ownerAddress); console.log('User NFTs:', objects); } Display NFT Data Fetch and display NFT data in your React app: function NFTList({ ownerAddress }) { const [nfts, setNFTs] = useState([]); useEffect(() => { async function loadNFTs() { const response = await provider.getObjectsOwnedByAddress(ownerAddress); setNFTs(response.data); } loadNFTs(); }, [ownerAddress]); return ( {nfts.map((nft) => ( {nft.name} Price: {nft.price} SUI ))} ); } Step 4: Enhancing Security and Performance 1. Secure Transactions Ensure all transactions are validated both on-chain and off-chain. Use libraries like @mysten/sui.js to verify transaction receipts: async function verifyTransaction(txDigest) { const result = await provider.getTransaction({ digest: txDigest }); console.log('Transaction Verified:', result); } 2. Optimize Gas Fees Partner with services like Shami Gas Station to offer gasless transactions, improving user experience. Alternatively, batch transactions to reduce costs (https://docs.sui.io/gas-optimization). 3. Leverage Sui’s Scalability Sui’s architecture supports high throughput and low latency, making it ideal for dApps with heavy usage. Test your application under simulated load conditions to ensure performance remains consistent (https://performance.sui.io). Step 5: Testing and Debugging Testing is critical to avoid vulnerabilities. Use tools like Sui Explorer to monitor transactions and debug issues. Additionally, write unit tests for your Move modules: #[test] fun test_mint_nft() { use sui::test_scenario; let ctx = &mut test_scenario::ctx(); let nft = examples::nft_marketplace::mint_nft(ctx, "Test NFT", 100); assert!(nft.price == 100, 0); } Run your tests using the Sui CLI: sui move test Step 6: Engaging with the Community Building dApps is not just about coding—it’s also about collaboration. Share your progress on platforms like GitHub, Discord, or Twitter. Participate in hackathons and developer challenges hosted by the Sui Foundation to refine your skills and gain exposure. Conclusion By mastering advanced Move concepts, writing modular smart contracts, and building intuitive frontends, you’re well on your way to becoming a proficient dApp developer on the Sui blockchain. Remember to prioritize security, optimize performance, and engage with the community to maximize your impact. Stay tuned for Course #3, where we’ll explore real-world use cases and advanced techniques for scaling your dApps on Sui! If you’d like further clarification or additional resources, feel free to ask!

HaGiang134

Apr 30, 2025

Article

This post was inspired when I saw the thread on X about the Walrus Ecosystem Map. You can access it here: 0xPain.sui🦭/acc「🦑」 Infrastructure & Developer Tools TuskyTools: Offers a suite of tools facilitating seamless interaction with the Sui ecosystem. nami_hq, RedundexHQ, linera_io, ikadotxyz, silvana_zk, SoundnessLabs: These projects contribute to the foundational infrastructure, enhancing scalability, interoperability, and security within the Sui network. Artificial Intelligence Integration TalusNetwork, nigiru_sui, Atoma_Network: Integrate AI capabilities with decentralized storage, enabling intelligent data processing and management. 💰 Decentralized Finance (DeFi) suibooster, deeptrade, mywebacy, 7k_ag, WalrusLST, Magma_Finance, PinataBotOnSui, get_nimbus, CetusProtocol, HaedalProtocol: These platforms leverage Walrus’s storage solutions to offer innovative financial products and services, enhancing the DeFi landscape on Sui. 🎮Gaming Applications sealionsui, SUIvivorGame, tajumaruxxx, wata_sui, TheVendettaGame, super_b_io, 0xCoinFever, onefightarena: Utilize Walrus for storing game assets, ensuring secure and efficient data retrieval for immersive gaming experiences. Social Platforms Unchained_pod, WalrusProetry, getbeluga, SuicastAI, BlobLifeLabs, FanTV_official, Suia2023, HackenProof: These projects enhance social interaction and content sharing, backed by Walrus’s decentralized storage capabilities. 🖼️ Non-Fungible Tokens (NFTs) Claynosaurz, tradeportxyz: Leverage Walrus to store and manage NFT assets, ensuring authenticity and permanence. 🐸 Memecoins & Decentralized Physical Infrastructure (DePIN) stakedotsui: A memecoin project utilizing Walrus for community engagement and token distribution. 3DOSNetwork: Focuses on decentralized physical infrastructure, integrating Walrus for data storage and management. Conclusion The Walrus ecosystem exemplifies the potential of decentralized storage solutions in enhancing various sectors within the Web3 space. By providing scalable, secure, and efficient data management, Walrus supports a diverse range of applications, from DeFi and gaming to social platforms and NFTs. As the ecosystem continues to grow, it stands as a testament to the innovative capabilities of the Sui blockchain and the broader decentralized technology landscape.

harry phan381

Apr 30, 2025

Article

Welcome to the next level of Sui Move development. In this hands-on guide, we're diving deep into DeepBook — the powerful CLOB (Central Limit Order Book) engine in the Sui ecosystem to show you how to build a DEX from scratch. Whether you're prototyping DeFi apps or exploring token mechanics, this tutorial will walk you through smart contract creation, interaction, and testing using DeepBook's latest modules. Introduction: Why DeepBook Matters If you're familiar with DeFi protocols like Uniswap or dYdX, you'll know how essential a performant, on-chain order book is. DeepBook brings that capability to Sui with a natively composable design. It enables limit orders, market orders, liquidity pools, and custodial accounts — all wrapped in Move modules. This article follows up on our previous intro to DeepBook and gets fully practical: we'll show you how to mint tokens, create liquidity pools, deposit/withdraw assets, and execute both limit and market orders. Setting Up Your Project Start by creating a new Move project: $ sui move new howtosui_deepbook We'll build two modules: usdt: a custom quote asset token deepbook: our interaction logic with DeepBook modules USDT Token Module module howtosui::usdt { use sui::coin::{Coin, TreasuryCap, Self}; public struct USDT has drop {} fun init(witness: USDT, ctx: &mut TxContext) { let (treasury, metadata) = coin::create_currency(witness, 6, b"USDT", b"", b"", option::none(), ctx); transfer::public_freeze_object(metadata); transfer::public_transfer(treasury, tx_context::sender(ctx)) } public entry fun mint(treasury_cap: &mut TreasuryCap, amount: u64, recipient: address, ctx: &mut TxContext) { treasury_cap.mint_and_transfer(amount, recipient, ctx) } public entry fun burn(treasury_cap: &mut TreasuryCap, coin: Coin) { treasury_cap.burn(coin); } } DeepBook Module Integration module howtosui::deepbook { use deepbook::clob_v2 as deepbook; use deepbook::custodian_v2 as custodian; use sui::coin::{Coin, Self}; use sui::clock::Clock; const FLOAT_SCALING: u64 = 1_000_000_000; public fun new_pool(payment: &mut Coin, ctx: &mut TxContext) { let fee = coin::balance_mut(payment).split(100 * FLOAT_SCALING); let coin = coin::from_balance(fee, ctx); deepbook::create_pool(1 * FLOAT_SCALING, 1, coin, ctx); } public fun new_custodian_account(ctx: &mut TxContext) { transfer::public_transfer(deepbook::create_account(ctx), tx_context::sender(ctx)); } public fun make_base_deposit(pool: &mut deepbook::Pool, coin: Coin, account_cap: &custodian::AccountCap) { deepbook::deposit_base(pool, coin, account_cap); } public fun make_quote_deposit(pool: &mut deepbook::Pool, coin: Coin, account_cap: &custodian::AccountCap) { deepbook::deposit_quote(pool, coin, account_cap); } public fun withdraw_base(pool: &mut deepbook::Pool, quantity: u64, account_cap: &custodian::AccountCap, ctx: &mut TxContext) { let base = deepbook::withdraw_base(pool, quantity, account_cap, ctx); transfer::public_transfer(base, tx_context::sender(ctx)); } public fun place_limit_order( pool: &mut deepbook::Pool, client_order_id: u64, price: u64, quantity: u64, self_matching_prevention: u8, is_bid: bool, expire_timestamp: u64, restriction: u8, clock: &Clock, account_cap: &custodian::AccountCap, ctx: &mut TxContext ): (u64, u64, bool, u64) { deepbook::place_limit_order(pool, client_order_id, price, quantity, self_matching_prevention, is_bid, expire_timestamp, restriction, clock, account_cap, ctx) } public fun place_base_market_order( pool: &mut deepbook::Pool, account_cap: &custodian::AccountCap, base_coin: Coin, client_order_id: u64, is_bid: bool, clock: &Clock, ctx: &mut TxContext ) { let quote_coin = coin::zero(ctx); let quantity = coin::value(&base_coin); place_market_order(pool, account_cap, client_order_id, quantity, is_bid, base_coin, quote_coin, clock, ctx); } fun place_market_order( pool: &mut deepbook::Pool, account_cap: &custodian::AccountCap, client_order_id: u64, quantity: u64, is_bid: bool, base_coin: Coin, quote_coin: Coin, clock: &Clock, ctx: &mut TxContext ) { let (base, quote) = deepbook::place_market_order(pool, account_cap, client_order_id, quantity, is_bid, base_coin, quote_coin, clock, ctx); transfer::public_transfer(base, tx_context::sender(ctx)); transfer::public_transfer(quote, tx_context::sender(ctx)); } } Environment Setup: Localnet Testing Run your validator locally: $ sui client switch --env localnet Create two accounts: $ sui client new-address ed25519 yasmine $ sui client new-address ed25519 yoyo Fund both via local faucet. Deploy & Interact 4.1 Publish Modules $ sui client publish --gas-budget 100000000 Export key objects like PACKAGE_ID, TREASURY_CAP_ID, POOL_ID, etc. 4.2 Mint Quote Token (USDT) $ sui client call --function mint ... 1000000000 4.3 Create Pool $ sui client call --function new_pool --args 4.4 Create Custodian Account $ sui client call --function new_custodian_account 4.5 Deposit Assets $ sui client call --function make_base_deposit $ sui client call --function make_quote_deposit 4.6 Place Limit Orders $ sui client call --function place_limit_order --args 4.7 Execute Market Orders $ sui client call --function place_base_market_order Wrap-Up With DeepBook, Sui offers a fully on-chain, composable, and efficient orderbook engine suitable for high-performance DeFi protocols. From token minting to order execution, every component is programmable and testable via Move. This guide gives you the baseline to build your own trading platforms, liquidity strategies, or even complex DAO-governed DeFi ecosystems on Sui. Stay tuned for Part 3, where we dive into event parsing, order history tracking, and frontend integration using the Sui SDK. Let’s keep BUIDLing