DEV Community: Bhanavi Goyal

Building a Trustless Escrow dApp on Sui: My Learning Journey

Bhanavi Goyal — Mon, 12 May 2025 05:39:12 +0000

I recently built a simple—but surprisingly deep—escrow application on the Sui blockchain. My goal was to learn Move, master Sui’s object model, and tie it all together with a React + TypeScript frontend. Along the way I hit a bunch of hurdles—some in Move, others in Typescript—and each taught me something new. Here’s the story of how I built my first dApp on sui and what all problems I faced along the way.

Why I Chose Sui & Move

Everything is an object On Sui, NFTs and coins are actual objects you can move around easily. That means I don’t need to deal with complex smart contract state—just send or modify an object directly.
No silly bugs with assets Move is strict. You can’t lose or duplicate tokens by mistake. If I try something unsafe with an NFT (like forgetting to return it), it won’t even compile. That’s a huge plus when you’re handling swaps or locks.
Frontend is super smooth Thanks to @mysten/dapp-kit, I could plug Sui into my React project with minimal effort. I didn’t have to write custom wallet logic or complex RPCs—it all felt like writing regular web code.
Helpful structure for learning Move forces you to think clearly about ownership, transfers, and safety. At first it was hard, but now I feel like I understand smart contracts better than I ever did with Solidity.

How the Escrow Works (Alice & Bob)

Let’s understand this with Alice and Bob — two NFT collectors who want to trade safely.

🤝Bob locks his NFT

Bob wants to exchange his NFT, but he doesn’t want to risk it being taken without a fair trade. So, he uses the on-chain lock() function to lock his NFT, which generates a unique Key.
This Key is like a secret code that can unlock the NFT later.
He then shares this Key with Alice (off-chain).

🔒 Why lock?

Once locked, Bob can’t transfer, sell, or tamper with the NFT.

If Bob tries to unlock it manually, the Key gets destroyed.

So if he unlocks it after Alice creates an escrow using the Key, the swap will fail — ensuring trust.

🤝Alice creates the escrow

Alice takes:

The Key Bob gave her
One of her own unlocked NFTs
Bob’s wallet address

She then calls create_escrow() on-chain, locking in:

The Key (to Bob’s NFT)
Her own NFT
Bob’s address (recipient)

This creates an on-chain escrow object visible to Bob.

🤝Bob accepts or rejects the trade

Bob now sees this escrow in his “Received Escrows”.

He can:

Call swap() to complete the trade — both NFTs are swapped using the smart contract.
Or call unlock() to reject it — and retrieve his locked NFT (but the Key changes, so the swap can’t happen).

🧠 Why This Matters

🔐 Tamper-proof:
Because Bob’s NFT is locked, Alice knows it won’t disappear before the trade. And if it does, the swap fails safely.

🛠️ Trustless exchange:
This setup removes the need for a trusted middleman or marketplace. Alice and Bob only rely on the smart contract logic to perform a secure and fair exchange.

No third party. No risks. Just code.

Key Challenges & How I Solved Them

1. Move Option<T> & option::extract
Symptom: My escrow struct wrapped the NFT in Option. Calling option::extract moves the value out, leaving None. When I later tried to read or re-extract it, the transaction aborted.

Fix: Always guard with assert!(option::is_some(&escrow.escrowed_obj), …) before extracting, and never touch that field again unless you reinitialize or return it.

2. Fetching data fields from the getOwnedObjects()
Symptom: getOwnedObjects() by default only returns { objectId, version, digest }. My .fields calls on obj.data.content failed silently.

Fix: Request full data:

await client.getOwnedObjects({
  owner: address,
  options: { showType: true, showContent: true }
});

then check:

if(nft.data.content?.dataType==="moveObject"){
   const fields = nft.data.content.fields as {
       name:string
   }
}

3. Listing Shared Escrows via Events
Symptom: Shared escrow objects live under a system “shared” address, not each user’s account, so getOwnedObjects() never showed them.

Fix: In create_escrow, emit a EscrowCreated event:

event::emit(EscrowCreated { id, sender: ctx.sender(), recipient });

Then on frontend:

const response = await client.queryEvents({
   query: {
      MoveEventType:"0x31b818703f625a7521c1a09d95f5cecddbaa0fe163bb83fe84d3105d86d14062::escrow::EscrowCreated",
   },
   limit: 50,
});

const events = response.data;

const objectPromises = events.map((event) => {
     const parsed = event.parsedJson as EscrowCreatedEvent;
     if (parsed?.id) {
    return fetchEscrowObject(parsed.id);
     }
     return null;
}).filter(Boolean);

Lessons & Takeaways

Move’s resource model is powerful but has a learning curve—especially around Option and object abilities (copy/drop).
Always request full RPC data (showType and showContent) before reading Move object fields.
Events + queryEvents are essential to track shared objects or past actions.
Clear separation of concerns—hooks for chain logic, context for state, components for UI—makes the app maintainable.

✨ Thanks for reading! Feel free to share or comment if you have questions or want to chat about Sui blockchain or Web3.

👉 Check out the code on GitHub: https://github.com/bhanavigoyal/sui-escrow
Feel free to star, fork, or DM me for collab! 🚀

➡️ I’m exploring Sui development with Move and on-chain assets. If you’re curious or building in Web3, let’s connect!

NFTs on Sui vs Solana vs Ethereum: A Beginner-Friendly Guide

Bhanavi Goyal — Tue, 22 Apr 2025 07:27:47 +0000

If you're new to the Web3 world and wondering why everyone keeps talking about NFTs, or why NFTs on Sui are such a big deal compared to Ethereum and Solana, you're in the right place. This blog will walk you through the basics of NFTs and show you how they differ across three popular blockchains: Ethereum, Solana, and Sui.

What Are NFTs, Really?

First let's start from the basics. NFT stands for Non-Fungible Token. It sounds technical, but it just means a unique digital item you can own — like digital art, a game item, a music track, or even a ticket. Unlike cryptocurrencies like Bitcoin or ETH, each NFT is unique and can't be swapped 1:1 with another.

Fungible Token (like ETH or SOL): All tokens are the same. If you trade one ETH for another, nothing changes.
Non-Fungible Token (NFT): Each one is different, with its own name, image, and data.

Think of an NFT like the Mona Lisa Painting. It is unique and can't be swapped with another painting.

But do NFTs really hold the image?

Not really. Most NFTs don’t keep the actual image inside them. They just hold a link to where the image is saved (usually on systems like IPFS or Arweave). So when you buy an NFT, you're getting a token that says, "Hey, the image is over there!" — not the image itself.

🌐 NFTs on Ethereum

Ethereum is where NFTs became popular. Most NFTs use a format called ERC-721, which is just a standard way to create and manage NFTs. Think of it like rules that everyone follows so NFTs work the same across different apps. For example, if you make a digital trading card, ERC-721 helps your wallet and marketplace understand how to show and trade it.

Imagine buying a movie ticket printed on paper:

You hold a physical ticket with a ticket number and showtime details.
Behind the scenes, the theater keeps its master schedule and seating chart in a computer system.
If you lose the ticket, the theater can look up your ticket number in their system to confirm your seat.

How Ethereum NFTs work:

Your wallet holds a token ID (like the ticket number).
That token ID points to metadata off-chain (like the theater’s database entry with movie info, time, seat).
The blockchain only tracks your token ID and link; it doesn’t store all the details.

Limitations:

All ticket details live off-chain (in the theater’s system).
Changing the showtime or seat requires updating the off-chain database, not the blockchain.
Transactions (minting/transferring) can be slow and costly when the network is busy.

⚡ NFTs on Solana

Solana is designed to be fast and cheap to use. It uses a system called Metaplex to create and manage NFTs.

On Solana, imagine a digital movie ticket in your phone’s wallet app:

Your phone creates a digital slot for each ticket you collect.
The ticket has a link (QR code) to an off-chain database with showtime and seat info.
You tap the ticket in your wallet, and it pulls up the details from the database.

How Solana NFTs work:

Your wallet sets up an Associated Token Account (ATA)—think of it as a dedicated pocket or sleeve in your digital wallet, created automatically for each NFT type you receive.
The ATA holds the actual token for that NFT mint, just like a specific sleeve in your wallet app holds one movie ticket. If you collect multiple tickets (NFTs), each goes into its own sleeve.
This separation helps your wallet easily manage and display each NFT correctly.
Without an ATA, your wallet wouldn’t know where to put or find that NFT, so every unique NFT mint needs its own ATA.
The NFT token in that ATA includes a metadata URI (like a link) pointing to off-chain data (movie info: seat, showtime, etc.).
Metaplex standardizes this process so wallets and apps can reliably fetch and display the NFT’s details.

Limitations:

Ticket details are off-chain; you rely on external servers.
Updating ticket data still means updating off-chain metadata and URI.
Changing details requires permission from the update authority (like the theater).

🔥 NFTs on Sui

Sui takes NFTs further by making them true on-chain objects—everything about the NFT (like name, image, and traits) is stored directly on the blockchain, not just a link. For example, imagine a library book that automatically stamps its own cover each time it's borrowed, so the book itself always shows its current status without any separate checkout log. And that is why it is sometimes called smart NFTs. How cool is that?

Let's go back to our movie ticket -

Now, imagine a movie ticket that you can upgrade and change. This ticket holds all the information about your movie experience—your seat, showtime, and special perks like VIP access—all within the ticket itself.
Upgrading your seat? You simply update the ticket with a new seat number. No need to go back to a database or change any external file.
The ticket holds all this information directly, meaning it’s always available and up-to-date.

How Sui NFTs work:

Sui NFTs are like these smart movie tickets—everything about them, from metadata to state, is stored fully on-chain.
Information such as your seat or perks is modifiable directly through smart contracts.
This makes Sui NFTs dynamic, allowing changes like seat upgrades to happen efficiently on-chain without relying on external servers or links.

Benefits:

Fully on-chain: no need for external servers or links.
Dynamic upgrades: tickets can be updated (seat changes, add-ons).
Transparent history: every change is recorded and verifiable.

Limitations:

Newer ecosystem—fewer libraries and tools than Ethereum or Solana.
Developers need to learn Sui’s Move programming language.

🚀 Why Sui NFTs Matter

With Sui, NFTs aren’t just static items—they’re living, evolving digital assets. This opens up a whole new world of possibilities:

Epic game items that grow with you—level up, evolve, and gain new abilities over time.
Membership passes that auto-update to unlock exclusive perks as the game world or experience changes.
Dynamic collectibles that adapt to real-world events and player actions in real-time, creating an ever-changing experience.

Ethereum introduced NFTs, Solana made them fast and cheap, and Sui is making them truly dynamic.

🧠 Final Thoughts

If you're new to Web3, understanding NFTs on different blockchains is key. Ethereum’s ERC-721 set the standard, Solana’s Metaplex scaled performance, and Sui’s object-centric design adds real interactivity.

➡️ I’m exploring Sui development with Move and on-chain assets. If you’re curious or building in Web3, let’s connect!

✨ Thanks for reading! Feel free to share or comment if you have questions or want to chat about NFTs or Web3.