Asset Tokenization: A Comprehensive Guide

Asset tokenization is the process of converting the ownership rights of real-world assets—like real estate, art, commodities, or stocks—into digital tokens on a blockchain. This innovative approach enables fractional ownership, making high-value investments more accessible and manageable.

Understanding Asset Tokenization

At its core, asset tokenization divides valuable assets into smaller, digital units. These units, represented as tokens, allow multiple investors to own a fraction of an asset rather than requiring a single owner to bear the full cost. This model lowers entry barriers and diversifies risk.

This concept is similar to the ERC1155 multi-token standard but includes additional functionality, making it suitable for Solidity-based use cases on the Sui blockchain.

How Tokenization Works

• Asset Creation: Each asset is divided into a total supply of fractions, represented as either fungible tokens (FTs) or non-fungible tokens (NFTs). Every fraction has a balance of at least one, and collectively, they represent the asset’s total value.
• Metadata Consistency: Key details like the asset’s name, description, and other attributes form its metadata, which remains uniform across all fractions.

NFTs vs. FTs: Key Differences

• Non-Fungible Tokens (NFTs): If a token includes unique metadata, it is classified as an NFT. Each NFT has a balance of one, indicating its uniqueness.
• Fungible Tokens (FTs): Tokens without unique metadata are FTs. Their balance can exceed one, allowing for multiple identical instances. FTs can be merged or split, providing flexibility in managing quantities.

Burnability

When creating an asset, you can specify whether its fractions are burnable—meaning they can be permanently removed from circulation. Burning a token reduces the circulating supply but does not alter the total supply, allowing burned fractions to be re-minted if necessary.

Move Packages for Asset Tokenization

On the Sui blockchain, Move programming language powers asset tokenization logic. The following packages and modules are central to this process.

Asset Tokenization Package

This reference implementation uses the Kiosk standard to ensure tokenized assets adhere to defined policies, including royalties and commissions. If the Kiosk standard isn’t required, you can exclude the unlock module and related proxy methods.

Key modules include:

• tokenized_asset
• proxy
• unlock

The tokenized_asset module functions similarly to the coin library. It handles asset creation, minting, splitting, joining, and burning.

Core Structs

• AssetCap: Generated for each new fractional NFT asset, this struct tracks circulating supply, total supply, and burnability.
• AssetMetadata: Defines metadata for the fractionalized asset (e.g., name, symbol, description).
• TokenizedAsset: Represents minted tokens with a balance and metadata. Populated VecMap indicates an NFT; empty VecMap indicates an FT.
• PlatformCap: Grants deployers specific permissions within the contract.

Essential Functions

• init: Creates and sends a PlatformCap to the sender.
• new_asset: Defines a new asset’s attributes and returns AssetCap and AssetMetadata objects.
• mint: Mints tokenized assets. With new metadata, it creates an NFT; without, it creates an FT.
• split: Divides an FT into two separate tokens with specified balances.
• join: Merges two FTs into one, burning the second token.
• burn: Removes a token from circulation, reducing the circulating supply.
• Helper functions like total_supply, supply, and value retrieve critical asset information.

Template Package

This package enables browser-based asset creation using Rust WebAssembly (WASM). It serves as a template for new tokenized assets, allowing users to edit and publish contracts dynamically.

Key modules:

• template: Defines new assets by calling asset_tokenization::tokenized_asset::new_asset().
• genesis: Includes a one-time witness (OTW) for claiming publisher rights.

Operational Flows

Publishing and Minting

Publishing involves deploying smart contracts to the Sui network. You can do this manually or via automated scripts. After deployment, minting creates tokenized assets based on predefined metadata and supply rules.

Joining Tokens

The join operation combines two FTs into one. This process assumes tokens are minted, locked in a Kiosk, and executed within a single programmable transaction block (PTB).

Burning Tokens

Burning destroys a tokenized asset, reducing the circulating supply. This action requires the asset to be burnable and locked in a Kiosk.

Customization and Variations

The default implementation can be tailored to specific use cases. For example:

• Convenience Alterations: Combine multiple steps (e.g., purchase, borrowing, unlocking, joining) into a single function.
• Use Case Alterations: Redesign structs like AssetCap into Treasury and AdminCap to enable user-driven burning under admin authority.

Deployment and Publishing

Initial Setup

Before publishing, initialize the Sui Client CLI:

1. Run sui client and follow prompts to connect to a Sui full node.
2. Select a key scheme (e.g., ed25519) to generate a keypair.

Publishing Packages

• Manually: Use sui client publish --gas-budget 20000000 from the package directory. Store the package ID and registry ID in your .env file.
• Automatically: Run npm run publish-asset-tokenization to auto-fill network and package details in .env.

WebAssembly (WASM) Integration

WASM allows bytecode manipulation for web-based contract edits. To modify the template package:

1. Retrieve bytecode for template.mv and genesis.mv using xxd commands.
2. Update constants and identifiers in TypeScript files like bytecode-template.ts.
3. Publish the modified bytecode with dependencies.

TypeScript Interactions

After deployment, use TypeScript to interact with smart contracts:

• Create Transfer Policy: Establish rules for trading tokens.
• Add Rules: Modify transferPolicyRules.ts to include royalties, floor prices, etc.
• Select Kiosk: Designate a Kiosk for storing and managing tokens.
• Mint Tokens: Define metadata and balances for NFTs or FTs.
• Lock Tokens: Secure tokens in a Kiosk to enforce policy compliance.
• List and Sell: Set prices and list tokens for sale.
• Purchase: Buy listed items by specifying item details and seller Kiosk.
• Join and Burn: Merge FTs or destroy tokens as needed.
• Query Information: Retrieve balances, circulating supply, and total supply.

👉 Explore advanced tokenization strategies

Frequently Asked Questions

What is asset tokenization?
Asset tokenization converts physical or digital assets into blockchain-based tokens. This enables fractional ownership, making it easier to buy, sell, and trade high-value assets.

How do NFTs and FTs differ in tokenization?
NFTs represent unique assets with distinct metadata, while FTs represent identical, interchangeable units. NFTs have a balance of one, whereas FTs can have balances greater than one.

Can tokenized assets be burned?
Yes, if the asset is created with burnable settings. Burning removes tokens from circulation but doesn’t change the total supply, allowing re-minting if needed.

What is the role of the Kiosk standard?
The Kiosk standard enforces policies like royalties and transfer rules. It ensures tokenized assets are traded within defined parameters, protecting creator and investor interests.

How can I customize tokenization for my use case?
You can modify smart contracts to combine functions, redesign structs, or enable user-driven actions. Always test changes thoroughly to avoid unintended effects.

What tools are needed for deployment?
You’ll need the Sui CLI, a configured environment file (.env), and TypeScript for interactions. Automated scripts can simplify publishing and setup.