> For the complete documentation index, see [llms.txt](https://docs.xspaceprotocol.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.xspaceprotocol.io/getting-started/developer-docs/tokenization-framework.md).

# Tokenization Framework

#### **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**

1. **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.
2. **Metadata Standards**:
   * Integrates detailed metadata, including ownership, valuation, and asset-specific attributes.
   * Supports off-chain metadata storage using IPFS for large datasets.
3. **Interoperability**:
   * Compatible with Ethereum standards like ERC-20, ERC-721, and ERC-1155.
   * Facilitates cross-chain trading via XSPACE bridges.
4. **Fractional Ownership**:
   * Tokenize large assets (e.g., real estate) into smaller units, enabling fractional investment and ownership.
5. **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)**

```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**

1. Install IPFS:

   ```bash
   npm install ipfs-http-client
   ```
2. Upload metadata:

   ```javascript
   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);
   ```
3. 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)**

```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**

```solidity
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**

```solidity
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**

```solidity
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:

```bash
npm install @xspace/sdk
```

Use the SDK to query tokenized asset details:

```javascript
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.