Sui Talk Saturday space summary: BUILD!!

Big! A new feature is landing in the @SuiNetwork flavor of Move, and it improves A LOT the way you test your packages Let me introduce you to "Module Extensions" 🧵

Just dropped a new post on Move Systems, Not Syntax. This one breaks down Derived Objects in Sui Move; how they work, why they exist, and what makes them powerful. https://t.co/DIlqcBZPX9

We are excited to announce our partnership with @SuiNetwork to bring smart contract development in Move to the next level 💥 Together, we’re building new, audited primitives that combine speed, composability, and security empowering developers to build the best onchain apps.

: : [Report] Everything, Rebuilt: The Sui Stack Written by @steve_4p --- https://t.co/9qXXuAMRuo --- While many Layer 1 blockchains have relied on general-purpose SDKs to differentiate themselves through token design or go-to-market strategies, Sui took an entirely different

Wow thank you @SuiNetwork nice to know that builders are being acknowledged ❤️

slushed morning

Sui Move dev tip: When running your AWS Nitro Enclave in debug mode, it generates zeroed nitro attestations: PCR0: "000..0000" PCR1: "000..0000" PCR2: "000..0000" However, this attestation is valid and can be used in Nautilus, allowing you to improve your debugging workflows

@0xdracooo @ViDAonX Great find and write up! This is a relatively new feature. We debuted "request" in the Slush wallet at SuiFest on Oct 2, which is powered by this standard. The detailed docs were published recently, so you found them very shortly after they went live 👏

Party objects is the goated recently added imo

That’s what makes Sui’s design so quietly elegant. Every object carries a logical timestamp — a memory of “when” it changed in the flow of global computation and that timestamp keeps the whole DAG from collapsing into chaos.

That’s why version numbers in Sui behave like Lamport timestamps rather than counters, it’s the source of causal determinism. Looking back at the project I abandoned, I realize versioning is deterministic but by causal relationship not by linear counting.

This creates a transaction-object DAG (directed acyclic graph) where nodes are transactions and edges represent “object dependency” (output of one transaction → input of another). And since every object version can only be consumed once, the DAG remains acyclic

Each object’s new version number is derived as 1 + max(input_versions). This single rule enforces a partial order across the entire transaction graph. It guarantees that if two objects were touched in the same transaction, they both advance to the same “logical moment” in time

I realised versioning in Sui isn’t about incrementing an integer each time an object changes. It’s not counting how many times an object has been updated — it’s encoding causality. Every transaction takes a set of input objects, mutates them, and produces new versions as output.

So I went back to the docs. This time, I read slowly. And then it clicked. If a transaction transfers object O at version 5 using a gas object G at version 3, both O and G are updated to version 1 + max(5, 3) = 6 Damn! I was totally wrong all along (maybe not totally but yeah)

And honestly I didnt think much of it at the time — I simply abandoned the project concluding this was probably why it wasn’t already implemented or widely discussed But over the past weekend, I decided to revisit it and really ask myself why the versioning wasn’t deterministic

I ran into one simple but frustrating issue: “Users would still need a way to fetch recent object versions”. I’d assumed it was just incrementing sequentially like a counter, but it clearly wasn’t behaving that way. That became the main blocker

Over the weekend I came across one of my first projects getting started on Sui — an implementation of an Offline Transaction Relay Service - a service that allows offline signing and an on-chain submission via a relay node meaning users can perform transactions totally offline.

The Simple View I Had All Along I assumed versioning was simple. Each time an object is modified, its version just increments by 1. Straightforward, right? Object O starts at version 1, gets updated → version 2. Another tx updates the object? → version 3. Right? Nah