How to Create a Token: ERC-20 Standard Versus Sui Coin

Creating digital tokens is a foundational skill for blockchain developers, enabling everything from decentralized finance (DeFi) to in-game currencies. While Ethereum’s ERC-20 standard has long been the go-to model, newer blockchains like Sui are introducing innovative approaches that rethink how tokens are structured and managed. This article explores the key differences between creating an ERC-20 token on Ethereum and a Coin on Sui, focusing on technical implementation, ownership models, and real-world implications for developers.

Understanding Tokens in Blockchain Ecosystems

Tokens serve as digital representations of value across blockchain networks. They can function as native currencies, governance instruments, or utility assets within decentralized applications (dApps). Two prominent frameworks for token creation are Ethereum’s ERC-20 standard and Sui’s built-in Coin package.

Despite serving similar end goals—enabling transfer, minting, burning, and spending—the underlying architectures differ significantly due to each platform’s data model and smart contract design.

Core Keywords: ERC-20 token, Sui Coin, blockchain tokens, token creation, Move language, Ethereum vs Sui, smart contracts, DeFi tokens

Deploying an ERC-20 Token on Ethereum

Ethereum uses the ERC-20 standard, a widely adopted protocol defining a set of rules for fungible tokens. These tokens are implemented as smart contracts written in Solidity and deployed on the Ethereum Virtual Machine (EVM).

To create an ERC-20 token, follow these streamlined steps using the Remix IDE:

Open Remix IDE in your browser.
Select the ERC-20 project template from OpenZeppelin.
Navigate to Token.sol in the contracts directory.
Modify the constructor to include a _mint function, specifying initial supply:

contract MyToken is ERC20, ERC20Permit {
    constructor() ERC20("MyToken", "MTK") ERC20Permit("MyToken") {
        _mint(msg.sender, 1000 * 10 ** decimals());
    }
}

Click Compile, then go to Deploy & Run Transactions.
Choose Remix VM (Cancun) and deploy the contract.

Once deployed, your token exists as a smart contract on the blockchain. The deployment process compiles your code into EVM bytecode and stores it permanently.

👉 Discover how modern blockchain platforms simplify token creation with intuitive tools and faster execution.

How ERC-20 Tokens Represent Ownership

In the ERC-20 model, token balances are stored in a centralized mapping inside the contract:

mapping(address => uint256) private _balances;

This means:

Your balance isn’t a physical object—it's an entry in a global ledger.
Transfers update this mapping: deducting from one address and crediting another.
Wallets like MetaMask query multiple contracts via balanceOf() calls to display total holdings.

Every interaction—minting, transferring, or burning—modifies this shared state. This architecture works reliably but introduces overhead and requires consensus for every transaction.

Creating a Coin on Sui Using the Coin Package

Sui takes a fundamentally different approach. Instead of relying on mappings, Sui treats tokens as first-class objects using its native Coin package, written in the Move programming language.

Here’s how to initialize a custom coin:

use sui::coin::{Self, TreasuryCap};
use sui::transfer;

public struct MY_COIN has drop {}

fun init(witness: MY_COIN, ctx: &mut TxContext) {
    let (treasury, metadata) = coin::create_currency(witness, 6, b"MY_COIN", b"", b"", option::none(), ctx);
    transfer::public_freeze_object(metadata);
    transfer::public_transfer(treasury, ctx.sender())
}

Key components:

MY_COIN: A zero-sized type acting as a placeholder for your currency.
TreasuryCap: Grants authority to mint new coins. It can be transferred or destroyed (like renouncing ownership).
CoinMetadata: Contains metadata such as symbol and decimals.

After deployment, these objects exist directly in user wallets—not in a shared contract.

How Sui Coin Objects Work: Ownership by Design

On Sui, each coin is a distinct object you own. When new coins are minted:

A new Coin<T> object is created and sent to the recipient’s address.
Multiple coin objects of the same type can exist in your wallet.
Your total balance is the sum of all individual coin values.

Crucially:

Coins can be split into smaller denominations or merged into larger ones.
Because ownership is intrinsic, no central ledger needs updating.

This object-centric model aligns closely with real-world assets—like holding physical cash—where possession equals control.

👉 See how next-gen blockchains enable instant transactions and true digital ownership.

ERC-20 vs Sui Coin: Key Feature Comparison

Minting and Burning

Aspect	ERC-20	Sui
Minting	Updates `_balances` mapping in contract	Creates new `Coin<T>` object
Burning	Reduces balance in mapping	Destroys the coin object
Control	Controlled via access-restricted functions	Requires possession of `TreasuryCap`

Transferring Tokens

ERC-20: Calls transfer() on the contract, which validates and updates balances.
Sui: Directly sends the owned Coin object to another address—no contract call needed.

Because Sui transactions involving single-owner objects don’t require network-wide consensus, they execute in parallel, leading to high throughput and near-instant finality.

Spending in DeFi Protocols

ERC-20 relies on the approve-transfer pattern:

You approve a DeFi contract to spend your tokens.
The contract calls transferFrom() when executing trades.

This creates security risks—malicious contracts can drain approved balances.

Sui eliminates this risk:

You pass the actual Coin object into the function.
The protocol owns it during processing and returns a new coin object after swapping.

No approvals needed—only direct ownership transfers.

👉 Explore secure, efficient ways to build and manage tokens without complex permission systems.

Frequently Asked Questions (FAQ)

Q: Do I need to write smart contracts for every token on Sui?
A: No. The Sui Framework provides a reusable Coin package. You only need to define a unique type and initialize it using create_currency.

Q: Can I integrate Sui Coins with DeFi apps easily?
A: Yes. Since coins are first-class objects, they integrate natively with dApps. Developers pass them directly into functions, simplifying logic and reducing attack surface.

Q: Is the ERC-20 standard obsolete compared to Sui’s model?
A: Not obsolete, but limited by design. ERC-20 remains dominant due to ecosystem size, but newer blockchains like Sui offer better performance and safety for certain use cases.

Q: How does gas work when transferring Sui Coins?
A: The sender pays gas in SUI (the native token). Since single-owner transfers are fast and parallelizable, gas costs are typically lower than equivalent Ethereum transactions.

Q: Can I make my Sui Coin upgradable or pausable?
A: While possible through custom logic, Sui encourages immutable designs for security. Features like pausing require careful architecture using capabilities like TreasuryCap.

Why Developers Should Understand Both Models

While both systems support core token functionalities, their architectural philosophies reflect deeper design choices:

Ethereum (Account-Based Model): Centralized state management with proven reliability but scalability trade-offs.
Sui (Object-Centric Model): Decentralized ownership with parallel execution, ideal for high-frequency applications.

Developers transitioning from Ethereum may initially find Sui’s model unfamiliar—but those with object-oriented programming experience often find it more intuitive.

For teams building scalable dApps, understanding these differences is crucial for choosing the right platform based on performance needs, security requirements, and development complexity.

If you're exploring advanced token standards or preparing to launch your own asset, studying both ERC-20 and Sui Coin patterns provides valuable insight into the evolution of blockchain technology.

To dive deeper into Sui’s token framework, refer to the official Sui Coin documentation.