> 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/smart-contract.md).

# Smart Contract

#### **Smart Contract Development on XSPACE Protocol**

The XSPACE Protocol supports the development and deployment of Ethereum-compatible smart contracts, enabling seamless integration with existing blockchain tools and workflows. This guide provides an overview of smart contracts on XSPACE, including deployment, interaction, and best practices.

***

### **Overview of XSPACE Smart Contracts**

#### **1. Ethereum Virtual Machine (EVM) Compatibility**

XSPACE is **EVM-compatible**, meaning developers can write and deploy smart contracts using the same tools and languages (e.g., Solidity) as on Ethereum. This ensures a low learning curve for developers transitioning from other EVM-based blockchains.

#### **2. Key Features**

* **High Performance:**\
  Contracts execute with near-instant finality (\~1-2 seconds) thanks to XSPACE’s sharded architecture and Delegated Proof-of-Stake (DPoS 2.0).
* **Low Transaction Fees:**\
  XSPACE’s efficient consensus mechanism and sharding result in significantly lower gas costs compared to Ethereum.
* **Interoperability:**\
  Smart contracts can interact with external blockchains via XSPACE’s cross-chain bridges, enabling multi-chain dApps.
* **Enhanced Tokenization Standards:**\
  Use the **XSPACE Asset Tokenization Standard (XATS)** to tokenize real-world assets with integrated metadata and compliance tools.

***

### **Deploying Smart Contracts**

#### **Step 1: Create a Smart Contract**

Smart contracts on XSPACE are written in **Solidity**, a popular language for EVM-based blockchains.

**Example: A Simple Storage Contract**

Create a new file in your `contracts` directory, e.g., `SimpleStorage.sol`:

```solidity
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 private data;

    // Set the value of `data`
    function set(uint256 _data) public {
        data = _data;
    }

    // Retrieve the value of `data`
    function get() public view returns (uint256) {
        return data;
    }
}
```

***

#### **Step 2: Configure the Development Environment**

Ensure your `hardhat.config.js` file is configured for the XSPACE Testnet:

```javascript
require("@nomiclabs/hardhat-waffle");

module.exports = {
  solidity: "0.8.0",
  networks: {
    xspaceTestnet: {
      url: "https://testnet.xspaceprotocol.io/rpc",
      chainId: 80001,
      accounts: ["YOUR_PRIVATE_KEY"]
    }
  }
};
```

Replace `"YOUR_PRIVATE_KEY"` with the private key of your Testnet wallet (use Metamask to export it).

***

#### **Step 3: Deploy the Smart Contract**

Write a deployment script in the `scripts` directory, e.g., `deploy.js`:

```javascript
async function main() {
    // Compile and deploy the SimpleStorage contract
    const SimpleStorage = await ethers.getContractFactory("SimpleStorage");
    const contract = await SimpleStorage.deploy();
    await contract.deployed();

    console.log("Contract deployed to:", contract.address);
}

main().catch((error) => {
    console.error(error);
    process.exitCode = 1;
});
```

Deploy the contract to the XSPACE Testnet:

```bash
npx hardhat run scripts/deploy.js --network xspaceTestnet
```

***

#### **Step 4: Verify Deployment**

1. Note the contract address output from the deployment script.
2. Use the **XSPACE Testnet Explorer** to verify the contract:\
   [https://testnet-explorer.xspace.io](https://testnet-explorer.xspace.io/).

***

### **Interacting with Smart Contracts**

Once deployed, you can interact with your smart contract using tools like Hardhat, Web3.js, or Ethers.js.

***

#### **Method 1: Using Hardhat Console**

Hardhat provides an interactive console for directly interacting with deployed contracts.

1. Open the Hardhat console:

   ```bash
   npx hardhat console --network xspaceTestnet
   ```
2. Load the deployed contract:

   ```javascript
   const contract = await ethers.getContractAt("SimpleStorage", "DEPLOYED_CONTRACT_ADDRESS");
   ```
3. Call the `set` function to store a value:

   ```javascript
   await contract.set(42);
   ```
4. Retrieve the stored value using the `get` function:

   ```javascript
   const value = await contract.get();
   console.log("Stored value:", value.toString());
   ```

***

#### **Method 2: Using a JavaScript dApp**

Integrate your smart contract with a JavaScript frontend using **Ethers.js** or **Web3.js**.

**Frontend Setup**

Install Ethers.js:

```bash
npm install ethers
```

**Connect to the XSPACE Testnet**

Create a connection to the blockchain:

```javascript
const { ethers } = require("ethers");

// Connect to the XSPACE Testnet
const provider = new ethers.providers.JsonRpcProvider("https://testnet.xspaceprotocol.io/rpc");

// Wallet setup
const privateKey = "YOUR_PRIVATE_KEY";
const wallet = new ethers.Wallet(privateKey, provider);

// Contract ABI and address
const abi = [
    "function set(uint256 _data) public",
    "function get() public view returns (uint256)"
];
const contractAddress = "DEPLOYED_CONTRACT_ADDRESS";

// Create a contract instance
const contract = new ethers.Contract(contractAddress, abi, wallet);

// Interact with the contract
(async () => {
    // Set a value
    const tx = await contract.set(42);
    await tx.wait();

    // Get the value
    const value = await contract.get();
    console.log("Stored value:", value.toString());
})();
```

***

### **Best Practices for Smart Contract Development**

1. **Optimize Gas Usage:**
   * Avoid unnecessary state variables and computations.
   * Use view/pure functions wherever possible.
2. **Thorough Testing:**
   * Test contracts locally using Hardhat or Truffle.
   * Use tools like Chai for writing test cases.
3. **Security Audits:**
   * Always audit smart contracts to check for vulnerabilities like reentrancy, overflow/underflow, and improper access control.
4. **Use IPFS for Off-Chain Data:**
   * Store large metadata (e.g., property details, asset history) off-chain on IPFS and link it to the contract.

***

### **Next Steps**

1. **Build Advanced Contracts:** Explore multi-shard interactions, privacy-preserving transactions (zk-SNARKs), and token standards (ERC-20/721).
2. **Deploy dApps:** Create decentralized applications integrating smart contracts with frontend frameworks.
3. **Explore Tokenization:** Use the **XATS framework** to tokenize real-world assets.

This guide sets the foundation for building, deploying, and interacting with smart contracts on XSPACE.