Tokenization Framework

The XSPACE Asset Tokenization Standard (XATS) is a powerful framework designed to simplify the process of tokenizing real-world assets (RWAs) on the XSPACE Protocol. It enables developers, businesses, and asset owners to create, manage, and trade tokenized representations of physical and financial assets, providing transparency, liquidity, and fractional ownership.

XATS: XSPACE Asset Tokenization Standard

Overview of XATS

XATS is the backbone of tokenization on the XSPACE Protocol. It ensures uniformity and interoperability for all tokenized assets within the ecosystem.

Key Features

Compliance-Ready:
- Built-in support for Know Your Customer (KYC) and Anti-Money Laundering (AML) compliance.
- Customizable token rules to comply with jurisdiction-specific regulations.
Metadata Standards:
- Integrates detailed metadata, including ownership, valuation, and asset-specific attributes.
- Supports off-chain metadata storage using IPFS for large datasets.
Interoperability:
- Compatible with Ethereum standards like ERC-20, ERC-721, and ERC-1155.
- Facilitates cross-chain trading via XSPACE bridges.
Fractional Ownership:
- Tokenize large assets (e.g., real estate) into smaller units, enabling fractional investment and ownership.
Automated Income Distribution:
- Smart contracts automate dividend and rental income payouts to token holders.

Token Standards in XATS

XATS supports multiple token standards based on asset type and use case:

1. XATS-20 (Fungible Tokens)

Designed for commodities, currencies, and divisible financial instruments.
Example: Tokenizing 1 kilogram of gold into 1,000 fungible tokens.

2. XATS-721 (Non-Fungible Tokens)

For unique assets such as real estate, luxury items, and art.
Example: Tokenizing a specific property deed or a rare diamond.

3. XATS-1155 (Hybrid Tokens)

Combines fungible and non-fungible attributes, ideal for tokenizing assets like portfolios or bundles.
Example: Tokenizing a real estate fund with unique properties and shared investment pools.

Creating Tokenized Assets

Step 1: Deploy the XATS Factory Contract

The XATS framework includes a pre-built factory contract to streamline token creation.

Factory Contract Features

Minting Tokens: Create fungible or non-fungible tokens linked to real-world assets.
Metadata Attachment: Add descriptive information (e.g., location, valuation) via IPFS.
Ownership Management: Define initial ownership and transfer rights.

Deployment Example (Solidity)

pragma solidity ^0.8.0;

contract XATSFactory {
    event TokenCreated(address indexed owner, address tokenAddress);

    function createFungibleToken(string memory name, string memory symbol, uint256 supply) public returns (address) {
        address token = address(new FungibleToken(name, symbol, supply, msg.sender));
        emit TokenCreated(msg.sender, token);
        return token;
    }
}

contract FungibleToken {
    string public name;
    string public symbol;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;

    constructor(string memory _name, string memory _symbol, uint256 _supply, address _owner) {
        name = _name;
        symbol = _symbol;
        totalSupply = _supply;
        balanceOf[_owner] = _supply;
    }
}

Step 2: Attach Metadata

Use IPFS to store off-chain metadata for tokenized assets, such as property details, certifications, or appraisal reports.

Upload Metadata to IPFS

Install IPFS:
```
npm install ipfs-http-client
```

Upload metadata:

const IPFS = require('ipfs-http-client');
const ipfs = IPFS.create({ host: 'ipfs.infura.io', port: 5001, protocol: 'https' });

const metadata = {
    name: "Luxury Apartment",
    location: "123 Blockchain Street",
    valuation: "$500,000"
};

const result = await ipfs.add(JSON.stringify(metadata));
console.log("IPFS Hash:", result.path);

Store the returned IPFS hash in your smart contract for asset reference.

Step 3: Mint and Distribute Tokens

Mint tokens representing fractional ownership or other rights related to the asset.

Minting Example (Solidity)

function mint(address to, uint256 amount) public {
    require(msg.sender == owner, "Only owner can mint tokens");
    balanceOf[to] += amount;
    totalSupply += amount;
}

Step 4: Enable Automated Income Distribution

Automate revenue distribution (e.g., rental income or dividends) to token holders using smart contracts.

Example Distribution Logic

function distributeIncome() public payable {
    uint256 total = address(this).balance;
    for (uint256 i = 0; i < tokenHolders.length; i++) {
        address holder = tokenHolders[i];
        uint256 share = (balanceOf[holder] * total) / totalSupply;
        payable(holder).transfer(share);
    }
}

Managing Tokenized Assets

Ownership Transfers

Use smart contracts to enable secure and transparent ownership transfers.

Transfer Example

function transfer(address to, uint256 amount) public {
    require(balanceOf[msg.sender] >= amount, "Insufficient balance");
    balanceOf[msg.sender] -= amount;
    balanceOf[to] += amount;
}

Compliance Enforcement

XATS includes built-in compliance checks:

KYC/AML Enforcement: Restrict transfers to whitelisted addresses.
Geofencing: Restrict token access based on geographic rules.

Whitelist Example

mapping(address => bool) public whitelist;

function addToWhitelist(address account) public {
    require(msg.sender == owner, "Only owner can whitelist");
    whitelist[account] = true;
}
function transfer(address to, uint256 amount) public {
    require(whitelist[to], "Recipient is not whitelisted");
    // Transfer logic here
}

API and SDK Integration for Tokenized Assets

XSPACE provides an SDK and REST APIs to simplify interaction with tokenized assets.

SDK Example

Install the XSPACE SDK:

npm install @xspace/sdk

Use the SDK to query tokenized asset details:

const XSPACE = require('@xspace/sdk');
const asset = await XSPACE.getTokenDetails("TOKEN_ADDRESS");
console.log(asset);

REST API

Endpoint: https://api.xspaceprotocol.io
Functions:
- Query asset details: GET /assets/{tokenAddress}
- Retrieve metadata: GET /assets/{tokenAddress}/metadata

This tokenization framework provides the foundation for developers to create, manage, and trade tokenized assets seamlessly on the XSPACE Protocol. With compliance-ready tools and high interoperability, XATS ensures that real-world assets are securely and transparently brought on-chain.

PreviousSmart Contract NextValidator Setup

Last updated 5 months ago

pragma solidity ^0.8.0; contract XATSFactory { event TokenCreated(address indexed owner, address tokenAddress); function createFungibleToken(string memory name, string memory symbol, uint256 supply) public returns (address) { address token = address(new FungibleToken(name, symbol, supply, msg.sender)); emit TokenCreated(msg.sender, token); return token; } } contract FungibleToken { string public name; string public symbol; uint256 public totalSupply; mapping(address => uint256) public balanceOf; constructor(string memory _name, string memory _symbol, uint256 _supply, address _owner) { name = _name; symbol = _symbol; totalSupply = _supply; balanceOf[_owner] = _supply; } }

const IPFS = require('ipfs-http-client'); const ipfs = IPFS.create({ host: 'ipfs.infura.io', port: 5001, protocol: 'https' }); const metadata = { name: "Luxury Apartment", location: "123 Blockchain Street", valuation: "$500,000" }; const result = await ipfs.add(JSON.stringify(metadata)); console.log("IPFS Hash:", result.path);

function distributeIncome() public payable { uint256 total = address(this).balance; for (uint256 i = 0; i < tokenHolders.length; i++) { address holder = tokenHolders[i]; uint256 share = (balanceOf[holder] * total) / totalSupply; payable(holder).transfer(share); } }

mapping(address => bool) public whitelist; function addToWhitelist(address account) public { require(msg.sender == owner, "Only owner can whitelist"); whitelist[account] = true; } function transfer(address to, uint256 amount) public { require(whitelist[to], "Recipient is not whitelisted"); // Transfer logic here }