The InterPlanetary File System (IPFS) is a protocol, hypermedia and file sharing peer-to-peer network for storing and sharing data in a distributed file system.

IPFS

Sui is a Layer 1 protocol blockchain designed as the first internet-scale programmable blockchain platform.

Walrus is a decentralized storage and data availability protocol designed specifically for large binary files, or "blobs"

Walrus

Move is an executable bytecode language used to implement custom transactions and smart contracts. 

Move

Have you faced double-spend issues when multiple users hit the same shared object? What patterns do you rely on optimistic concurrency, tickets, or object cloning?

Preventing Double Spending in High-Load Apps

Do you store NFT metadata fully on-chain, partially on-chain, or completely off-chain (IPFS/Arweave)? How do you weigh decentralization against scalability and cost?

Metadata Storage for NFTs

Unit tests in Move can save hours of debugging. Do you prefer writing exhaustive tests upfront, or building minimal tests and iterating? How do you mock dependencies effectively?

Unit Testing Best Practices in Move

Shared objects are essential for liquidity pools and AMMs, but they often become hotspots. Have you found good ways to reduce contention? Do you use sharding, secondary owned objects, or off-chain batching to keep throughput high?

Optimizing Shared Objects in DeFi Protocols

Hello Everyone, 


Yester I called Chase Travel on 1855-546-5045 and i have made my reservation and that made my day !!! You guys can call on this 1855-546-5045 to work with chase Flight tickets, Changes and Cancellation.

Thanks 

Chase !!!

Called Chase Travel Support

I am new to the Trading i would like to know more about short and Long trade anyone can suggest me on that

New in Trading need to know more about short or Long Trade

_由于 Move 模块在发布后是不可变的，因此升级规划是开发的关键部分. 我见过开发人员保留指向当前逻辑版本的 “主对象” 的模式，但我想知道哪些策略在实践中效果最好. _

_Since Move modules are immutable after publishing, planning for upgrades is a critical part of development. I’ve seen patterns where devs keep a “master object” that points to the current logic version, but I’m wondering what strategies work best in practice._

Future-proofing Move modules without breaking compatibility

经得起未来考验的 Move 模块，不破坏兼容性

我想知道是否有办法在Sui框架内销毁或自毁智能合约. 我听说过一些关于 “自毁” 机制的消息，想知道它是否存在于 Sui 中. 另外，如果以这种方式终止合同，会发生什么？

I was wondering if there's a way to destroy or self-destruct a smart contract within the Sui framework. I heard something about a 'selfdestruct' mechanism and wanted to know if it exists in Sui. Also, what would happen if a contract is terminated in this manner?

Does Sui support contract self-destruction?

Sui 支持合同自我毁灭吗？

我想了解Otw功能是否只能调用一次，尤其是在初始化或创建硬币的背景下. 有人能解释一下它的目的吗？

I'm trying to understand if the Otw functionality is meant to be called only once, especially in the context of initializing or creating a coin. Could someone explain its purpose?

Is Otw available only for the first time?

Otw 仅在第一次可用吗？

<String>我正在尝试在 Sui 上设置一个唯一的用户名注册表，并正在考虑使用 vec_set. 我担心它的可扩展性. 这是唯一的方法吗？它如何在 Sui 上扩展？

I'm trying to set up a unique registry of user names on Sui and am considering using vec_set<String>. I'm concerned about its scalability. Is this the only way, and how does it scale on Sui?

Best way to handle a unique user registry on Sui?

在Sui上处理唯一用户注册表的最佳方法是什么？

Move’s generics enable reusable, type-safe code, critical for DeFi protocols handling multiple token types. Intermediate developers must apply constraints like key and store to ensure compatibility with Sui’s object model.
Why are generics useful in Move for building reusable DeFi modules? Write a generic Move module for a vault that can store and withdraw any coin type. What constraints ensure the module works with Sui’s coin system?
```
module vault::generic_vault {
    use sui::object::{Self, UID};
    use sui::coin::{Self, Coin};
    use sui::balance::{Self, Balance};
    use sui::tx_context::{Self, TxContext};
    use sui::transfer;

    struct Vault has key {
        id: UID,
        balance: Balance,
    }

    // Create vault for any coin type
    public entry fun create_vault(ctx: &mut TxContext) {
        let vault = Vault {
            id: object::new(ctx),
            balance: balance::zero(),
        };
        transfer::share_object(vault);
    }

    // Deposit coins into vault
    public entry fun deposit(vault: &mut Vault, coin: Coin) {
        coin::put(&mut vault.balance, coin);
    }

    // Withdraw coins (simplified to sender)
    public entry fun withdraw(
        vault: &mut Vault,
        amount: u64,
        ctx: &mut TxContext
    ) {
        let coin = coin::take(&mut vault.balance, amount, ctx);
        transfer::public_transfer(coin, tx_context::sender(ctx));
    }
}
```

Generic Types in Move for Reusability

Sui supports parallel execution. How does Move code need to be structured to benefit from this feature?

How does Move handle parallel execution?

If a process needs multiple user interactions (like a game or auction), what’s the best way to structure state and transactions?

How do I design multi-step workflows in Move?

I'm trying to make swaps using the functions client.findRouters, client.fastRouterSwap, and client.signAndExecuteTransaction but frequently encounter the 'MoveAbort' error. My balance seems stable at 100+ SUI, yet 1 out of 10 transactions fails. This error still persists after restoring the blockchain. How can I figure out what's going wrong?

Why do I keep getting 'MoveAbort' error in signAndExecuteTransaction?

Sui’s object versioning ensures deterministic outcomes in parallel transaction execution by tracking object versions and resolving conflicts via consensus (Narwhal/Bullshark). Intermediate developers must handle versioning to avoid conflicts in shared objects.

```
module leaderboard::shared_leaderboard {
    use sui::object::{Self, UID};
    use sui::tx_context::{Self, TxContext};
    use sui::transfer;
    use sui::dynamic_field as df;

    struct Leaderboard has key {
        id: UID,
    }

    // Create shared leaderboard
    public entry fun create_leaderboard(ctx: &mut TxContext) {
        let leaderboard = Leaderboard { id: object::new(ctx) };
        transfer::share_object(leaderboard);
    }

    // Update user score (Sui versioning ensures atomic updates)
    public entry fun update_score(leaderboard: &mut Leaderboard, user: address, score: u64) {
        df::add(&mut leaderboard.id, user, score);
        // Sui’s consensus ensures versioned updates are ordered
    }

    // Get user score
    public fun get_score(leaderboard: &Leaderboard, user: address): u64 {
        if (df::exists_(&leaderboard.id, user)) {
            *df::borrow(&leaderboard.id, user)
        } else {
            0
        }
    }
}
```
How does Sui’s object versioning prevent race conditions? Write a Move module for a shared leaderboard where users update scores, and explain how Sui ensures consistency if multiple users update simultaneously.

讨论

与Move社区分享您的想法

赚取你的 1000 Sui 份额

帖子