Smart Contract

Smart ContractAICChain currently supports Solidity versions <= 0.8.8 for compilation. Support for later versions will be gradually introduced based on official announcements.

AICChain is fully compatible with the Ethereum Virtual Machine (EVM), enabling developers to seamlessly deploy and execute smart contracts written in Solidity. This document provides an introduction to the essentials of smart contract development on AICChain.

---

Contract Development

Development Environment

To develop smart contracts on AICChain, you’ll need:

1. Code Editor: Tools like VSCode or Remix.

2. Solidity Compiler: For compiling your Solidity code.

3. Web3 Development Framework: Options include Hardhat or Truffle.

4. AICChain RPC Endpoint: To connect to the AICChain network (e.g., https://rpc.aicchain.io for testnet).

---

Contract Deployment

You can deploy smart contracts to AICChain using:

1. Remix IDE: Connect to the AICChain network via the “Injected Web3” provider (e.g., MetaMask configured with AICChain RPC).

2. Hardhat or Truffle: Use deployment scripts tailored to AICChain network settings.

3. Web3 Library: Interact directly with the network using libraries like Web3.js or ethers.js.

Example: Deploying with Hardhat

const hre = require("hardhat");

async function main() {
  const [deployer] = await hre.ethers.getSigners();
  console.log("Deploying from:", deployer.address);

  const MyContract = await hre.ethers.getContractFactory("MyContract");
  const contract = await MyContract.deploy();
  await contract.deployed();

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

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

Configure Hardhat with AICChain network:

// hardhat.config.js
module.exports = {
  solidity: "0.8.8",
  networks: {
    aicchain_testnet: {
      url: "https://testnet-rpc.aicchain.org",
      chainId: 3018,
      accounts: ["your_private_key"]
    }
  }
};

---

Best Practices

When developing smart contracts for AICChain:

1. Thorough Testing: Test contracts extensively using frameworks like Hardhat or Truffle to catch bugs early.

2. Security Practices: Follow guidelines like OpenZeppelin’s security recommendations to prevent vulnerabilities (e.g., reentrancy, overflow).

3. Gas Optimization: Minimize gas costs by optimizing loops, storage usage, and function calls.

4. Stable Solidity Version: Use the latest stable Solidity version supported by AICChain (currently <= 0.8.8).

5. Access Control: Implement role-based access (e.g., OpenZeppelin’s Ownable or AccessControl) to restrict sensitive functions.

Example: Simple Contract with Access Control

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.8;

import "@openzeppelin/contracts/access/Ownable.sol";

contract MyContract is Ownable {
    uint256 public value;

    function setValue(uint256 _value) external onlyOwner {
        value = _value;
    }
}

---

Contract Verification

After deployment, verify your contract’s source code on AICChain block explorer (e.g., https://scan.aicchain.io/) for transparency and security. Verification ensures users can audit the deployed bytecode against the source.

Steps for Verification:

1. Flatten Contract: If using multiple files or imports, flatten your code into a single file (e.g., using hardhat flatten).

2. Submit on Explorer: Provide the contract address, flattened source code, compiler version (e.g., 0.8.8), and constructor arguments (if any).

3. Confirm: Once verified, the explorer will display the contract’s source and ABI publicly.

Example: Hardhat Verification

// Run this after deployment
hre.run("verify:verify", {
  address: "deployed_contract_address",
  constructorArguments: [],
});

Requires the Hardhat Etherscan plugin and an API key (if applicable).