---

title: ERC1155 新合约 description: 多资产 ERC1155 RWA 平台 date: "2026-03-14" tags: [] cover: /images/rwa-cover.jpg

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

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

contract RWAPlatform1155Pro is
    ERC1155,
    ERC1155Supply,
    Ownable,
    ReentrancyGuard,
    Pausable
{
    using SafeERC20 for IERC20;

    IERC20 public immutable usdt;

    uint256 private constant ACC = 1e18;

    constructor(address _usdt) ERC1155("") Ownable(msg.sender) {
        usdt = IERC20(_usdt);
    }

    // =========================
    // Asset Struct
    // =========================

    struct Asset {
        uint256 price;
        uint256 minRaise;
        uint256 maxRaise;
        uint256 totalRaised;
        uint256 deadline;
        uint256 endTime;
        bool running;
        bool finished;
    }

    mapping(uint256 => Asset) public assets;

    // =========================
    // KYC
    // =========================

    mapping(address => bool) public whitelisted;

    event WhitelistSet(address indexed user, bool ok);

    function setWhitelist(address user, bool ok) external onlyOwner {
        whitelisted[user] = ok;
        emit WhitelistSet(user, ok);
    }

    function batchWhitelist(address[] calldata users, bool ok) external onlyOwner {
        for (uint256 i; i < users.length; i++) {
            whitelisted[users[i]] = ok;
            emit WhitelistSet(users[i], ok);
        }
    }

    // =========================
    // Investors
    // =========================

    mapping(uint256 => address[]) public investors;
    mapping(uint256 => mapping(address => bool)) public isInvestor;

    function getInvestors(uint256 id) external view returns (address[] memory) {
        return investors[id];
    }

    // =========================
    // Profit Model
    // =========================

    mapping(uint256 => uint256) public accProfitPerShare;
    mapping(uint256 => mapping(address => uint256)) public profitDebt;
    mapping(uint256 => mapping(address => uint256)) public pending;

    // =========================
    // Investment Record
    // =========================

    mapping(uint256 => mapping(address => uint256)) public investedAmount;

    struct SubscribeOrder {
        address user;
        uint256 tokenId;
        uint256 usdtAmount;
        uint256 tokenAmount;
        uint256 timestamp;
    }

    SubscribeOrder[] public orders;

    // =========================
    // Events
    // =========================

    event AssetRegistered(uint256 indexed tokenId);
    event AssetStarted(uint256 indexed tokenId);

    event Subscribed(address indexed user,uint256 indexed tokenId,uint256 usdtAmount);
    event AdminSubscribed(address indexed user,uint256 indexed tokenId,uint256 usdtAmount);

    event ProfitInjected(uint256 indexed tokenId,uint256 amount);
    event Claimed(address indexed user,uint256 indexed tokenId,uint256 amount);

    event Redeemed(address indexed user,uint256 indexed tokenId,uint256 principal,uint256 profit);

    // =========================
    // Register Asset
    // =========================

    function registerAsset(
        uint256 tokenId,
        uint256 price,
        uint256 minRaise,
        uint256 maxRaise,
        uint256 deadline,
        uint256 duration
    ) external onlyOwner {

        require(assets[tokenId].price == 0, "asset exists");

        assets[tokenId] = Asset({
            price: price,
            minRaise: minRaise,
            maxRaise: maxRaise,
            totalRaised: 0,
            deadline: deadline,
            endTime: deadline + duration,
            running: false,
            finished: false
        });

        emit AssetRegistered(tokenId);
    }

    // =========================
    // Profit Update
    // =========================

    function _updateProfit(uint256 id,address user) internal {

        if (user == address(0)) return;

        uint256 bal = balanceOf(user,id);

        if (bal == 0) {
            profitDebt[id][user] = 0;
            return;
        }

        uint256 accumulated = (bal * accProfitPerShare[id]) / ACC;
        uint256 owing = accumulated - profitDebt[id][user];

        if (owing > 0) {
            pending[id][user] += owing;
        }

        profitDebt[id][user] = accumulated;
    }

    // =========================
    // Subscribe
    // =========================

    function subscribe(uint256 id,uint256 usdtAmount)
        external
        nonReentrant
        whenNotPaused
    {

        Asset storage a = assets[id];

        require(block.timestamp < a.deadline,"ended");
        require(whitelisted[msg.sender],"no KYC");
        require(a.totalRaised + usdtAmount <= a.maxRaise,"over raise");
        require(usdtAmount % a.price == 0,"invalid amount");

        uint256 amount = usdtAmount / a.price;

        usdt.safeTransferFrom(msg.sender,address(this),usdtAmount);

        a.totalRaised += usdtAmount;
        investedAmount[id][msg.sender] += usdtAmount;

        if (!isInvestor[id][msg.sender]) {
            investors[id].push(msg.sender);
            isInvestor[id][msg.sender] = true;
        }

        _mint(msg.sender,id,amount,"");

        orders.push(
            SubscribeOrder(
                msg.sender,
                id,
                usdtAmount,
                amount,
                block.timestamp
            )
        );

        emit Subscribed(msg.sender,id,usdtAmount);
    }

    // =========================
    // Admin Subscribe
    // =========================

    function adminSubscribe(
        address user,
        uint256 id,
        uint256 usdtAmount
    ) external onlyOwner nonReentrant {

        Asset storage a = assets[id];

        require(block.timestamp < a.deadline,"ended");
        require(whitelisted[user],"no KYC");
        require(a.totalRaised + usdtAmount <= a.maxRaise,"over raise");
        require(usdtAmount % a.price == 0,"invalid");

        uint256 amount = usdtAmount / a.price;

        usdt.safeTransferFrom(msg.sender,address(this),usdtAmount);

        a.totalRaised += usdtAmount;
        investedAmount[id][user] += usdtAmount;

        if (!isInvestor[id][user]) {
            investors[id].push(user);
            isInvestor[id][user] = true;
        }

        _mint(user,id,amount,"");

        orders.push(
            SubscribeOrder(user,id,usdtAmount,amount,block.timestamp)
        );

        emit AdminSubscribed(user,id,usdtAmount);
    }

    // =========================
    // Start Asset
    // =========================

    function startAsset(uint256 id) external onlyOwner {

        Asset storage a = assets[id];

        require(a.totalRaised >= a.minRaise,"below minRaise");
        require(!a.running,"already running");

        a.running = true;

        emit AssetStarted(id);
    }

    // =========================
    // Inject Profit
    // =========================

    function injectProfit(uint256 id,uint256 amount) external onlyOwner {

        Asset storage a = assets[id];
        require(a.running,"not running");

        uint256 supply = totalSupply(id);
        require(supply > 0,"no holders");

        usdt.safeTransferFrom(msg.sender,address(this),amount);

        accProfitPerShare[id] += (amount * ACC) / supply;

        emit ProfitInjected(id,amount);
    }

    // =========================
    // Claim
    // =========================

    function claim(uint256 id) external nonReentrant {

        _updateProfit(id,msg.sender);

        uint256 amt = pending[id][msg.sender];
        require(amt > 0,"no profit");

        pending[id][msg.sender] = 0;

        usdt.safeTransfer(msg.sender,amt);

        emit Claimed(msg.sender,id,amt);
    }

    // =========================
    // Redeem
    // =========================

    function redeem(uint256 id) external nonReentrant {

        Asset storage a = assets[id];

        require(block.timestamp >= a.endTime,"not ended");

        uint256 bal = balanceOf(msg.sender,id);
        require(bal > 0,"no token");

        _updateProfit(id,msg.sender);

        uint256 principal = investedAmount[id][msg.sender];
        uint256 profit = pending[id][msg.sender];

        pending[id][msg.sender] = 0;
        investedAmount[id][msg.sender] = 0;

        _burn(msg.sender,id,bal);

        usdt.safeTransfer(msg.sender,principal + profit);

        if (totalSupply(id) == 0) {
            a.finished = true;
        }

        emit Redeemed(msg.sender,id,principal,profit);
    }

    // =========================
    // Pause
    // =========================

    function pause() external onlyOwner {
        _pause();
    }

    function unpause() external onlyOwner {
        _unpause();
    }

    // =========================
    // Emergency Withdraw
    // =========================

    function emergencyWithdraw(uint256 amount) external onlyOwner {
        usdt.safeTransfer(msg.sender,amount);
    }

    // =========================
    // Disable Transfer
    // =========================

    function _update(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values
    ) internal override(ERC1155,ERC1155Supply) {

        for(uint256 i;i<ids.length;i++){

            require(
                from == address(0) || to == address(0),
                "non transferable"
            );

            _updateProfit(ids[i],from);
            _updateProfit(ids[i],to);
        }

        super._update(from,to,ids,values);
    }
}

功能完整度：

| 功能        | 支持 |
| --------- | -- |
| 多资产RWA    | ✔  |
| USDT认购    | ✔  |
| KYC白名单    | ✔  |
| 管理员代购     | ✔  |
| 批量KYC     | ✔  |
| 投资人列表     | ✔  |
| 分红模型      | ✔  |
| 批量分红      | ✔  |
| ERC1155份额 | ✔  |
| 不可转让      | ✔  |
| 到期赎回      | ✔  |
| 暂停        | ✔  |
| 紧急提取      | ✔  |
| 认购订单      | ✔  |

你的完整系统架构会是

Next.js 前端
     │
API Server
     │
PostgreSQL
     │
RWAPlatform1155Pro
     │
USDT

还需要：

如果你愿意，我可以 继续帮你补齐三个关键部分（非常关键）：

1️⃣ RWA后台数据库结构（Supabase/Postgres）
2️⃣ Next.js RWA 投资平台前端结构
3️⃣ 链上数据同步 Indexer（自动同步认购 / 分红 / 赎回）

这样你就拥有 完整 RWA 融资平台系统。

如何编译

npx hardhat compile

完整命令
npx hardhat compile --force

如何部署

npx hardhat run --network <network_name> scripts/deploy.js

npm install --save-dev hardhat typescript ts-node @types/node dotenv @nomicfoundation/hardhat-toolbox solc@0.8.20 npm install @openzeppelin/contracts@4.9.3

新建 Hardhat 项目配置（TypeScript）

import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import * as dotenv from "dotenv";

dotenv.config();

const config: HardhatUserConfig = {
  solidity: {
    compilers: [
      {
        version: "0.8.20",
        settings: {
          optimizer: { enabled: true, runs: 200 },
        },
      },
    ],
  },
  paths: {
    sources: "./contracts",
    cache: "./cache",
    artifacts: "./artifacts",
  },
  networks: {
    hardhat: {},
    localhost: { url: "http://127.0.0.1:8545" },
    sepolia: {
      url: process.env.RPC_URL || "https://sepolia.infura.io/v3/YOUR_INFURA_KEY",
      accounts: process.env.DEPLOYER_PRIVATE_KEY
        ? [process.env.DEPLOYER_PRIVATE_KEY]
        : [],
    },
  },
};

export default config;