RWA Tokenization Lab

contract AssetRegistry {
  struct Asset {
    string name;        // "Apple Inc. Common Stock"
    string symbol;      // "AAPL"
    string isin;        // "US0378331005"
    uint256 valuation;  // in USD (oracle-updated)
    AssetStatus status; // Pending, Active, Frozen, Delisted
    string metadataURI; // IPFS/Arweave link to legal docs
  }

  mapping(uint256 => Asset) public assets;
  uint256 public assetCount;

  function registerAsset(
    string memory name, string memory symbol,
    string memory isin, uint256 valuation, string memory uri
  ) external onlyAdmin returns (uint256 assetId);

  function updateValuation(uint256 assetId, uint256 newValuation) external onlyOracle;
  function freezeAsset(uint256 assetId) external onlyAdmin;
}

contract AssetNFT is ERC721 {
  uint256 public nextTokenId;
  mapping(uint256 => uint256) public tokenToAssetId; // NFT → AssetRegistry ID

  function mint(address to, uint256 assetId, string memory tokenURI)
    external onlyAssetRegistry returns (uint256);

  function burn(uint256 tokenId) external onlyVault; // redeem/burn on exit
}

contract FractionalToken is ERC20 {
  uint256 public nftTokenId;     // The NFT this token fractionalizes
  address public nftContract;    // AssetNFT address

  constructor(
    string memory name, string memory symbol,
    uint256 totalShares, address _nftContract, uint256 _nftTokenId
  ) {
    _mint(msg.sender, totalShares);
    nftContract = _nftContract;
    nftTokenId = _nftTokenId;
  }

  // Override transfer to check compliance
  function _update(address from, address to, uint256 amount)
    internal override(IERC20, ERC20) {
    require(IComplianceManager(compliance).canTransfer(from, to), "Transfer not allowed");
    super._update(from, to, amount);
  }
}

contract Vault {
  address public governance;
  address public treasury;
  uint256 public protocolFeeBps = 50; // 0.5%

  mapping(address => uint256) public balances;

  function deposit(address token, uint256 amount) external payable;
  function withdraw(address token, uint256 amount) external onlyGovernance;

  // Buy fractional tokens: payment in → tokens out
  function buyShares(address fractionalToken, uint256 shareAmount)
    external returns (bool);

  // Sell fractional tokens: tokens in → payment out (minus fee)
  function sellShares(address fractionalToken, uint256 shareAmount)
    external returns (bool);

  // Redeem: burn tokens, claim proportional asset proceeds
  function redeem(address fractionalToken, uint256 shareAmount)
    external returns (uint256 payout);
}

contract ComplianceManager {
  enum KYCStatus { None, Pending, Verified, Rejected, Revoked }

  mapping(address => KYCStatus) public kycStatus;
  mapping(address => bool) public isSanctioned;
  mapping(address => bytes2) public jurisdiction; // country code
  mapping(bytes2 => mapping(bytes2 => bool)) public allowedCorridors;

  // Called by token contracts before transfer
  function canTransfer(address from, address to)
    external view returns (bool)
  {
    if (isSanctioned[from] || isSanctioned[to]) return false;
    if (kycStatus[from] != KYCStatus.Verified) return false;
    if (kycStatus[to] != KYCStatus.Verified) return false;

    bytes2 fromCountry = jurisdiction[from];
    bytes2 toCountry = jurisdiction[to];
    if (!allowedCorridors[fromCountry][toCountry]) return false;

    return true;
  }

  function setKYC(address user, KYCStatus status) external onlyAdmin;
  function setSanctioned(address user, bool sanctioned) external onlyAdmin;
  function setJurisdiction(address user, bytes2 country) external onlyAdmin;
  function allowCorridor(bytes2 from, bytes2 to) external onlyAdmin;
}

contract TransferManager {
  mapping(address => bool) public isApprovedWallet; // allowlist
  mapping(address => uint256) public maxTransferAmount;
  mapping(address => uint256) public lockupUntil;   // timestamp

  struct TransferRule {
    bool requireAllowlist;
    bool requireCompliance;
    uint256 maxPerTx;
    uint256 cooldownPeriod;
  }

  mapping(address => TransferRule) public tokenRules; // per-token config

  function validateTransfer(
    address token, address from, address to, uint256 amount
  ) external view returns (bool) {
    TransferRule memory rule = tokenRules[token];
    if (rule.requireAllowlist) {
      require(isApprovedWallet[from] && isApprovedWallet[to], "Not approved");
    }
    if (rule.maxPerTx > 0 && amount > rule.maxPerTx) return false;
    if (block.timestamp < lockupUntil[from]) return false;
    return true;
  }

  function approveWallet(address wallet) external onlyAdmin;
  function setTokenRules(address token, TransferRule memory rules) external onlyAdmin;
}

contract IdentityRegistry {
  enum EntityType { Individual, Corporate, Institutional, Government }

  struct Identity {
    bytes32 identityHash;     // hash of legal documents (stored off-chain)
    EntityType entityType;
    bytes2 jurisdiction;      // country code
    bool isAccredited;        // accredited investor status
    uint256 verifiedAt;       // timestamp of KYC verification
    address delegate;         // authorized delegate (e.g., fund manager)
  }

  mapping(address => Identity) public identities;
  mapping(bytes32 => address) public hashToWallet; // prevent duplicate identities

  function registerIdentity(
    bytes32 identityHash, EntityType entityType,
    bytes2 jurisdiction, bool isAccredited
  ) external onlyKYCAuthority returns (bool);

  function getIdentity(address wallet)
    external view returns (Identity memory);

  function isVerified(address wallet) external view returns (bool);
}

contract Treasury {
  address public governance;
  address public multisig;           // where funds are sent
  uint256 public tradeFeeBps = 30;   // 0.3% per trade
  uint256 public redemptionFeeBps = 50; // 0.5% on redemption

  mapping(address => uint256) public collectedByToken; // fee tracking

  function collectFee(address token, uint256 amount, address payer)
    external onlyVault {
    collectedByToken[token] += amount;
    // Transfer fee to treasury multisig
    IERC20(token).transfer(multisig, amount);
  }

  function setTradeFee(uint256 bps) external onlyGovernance;
  function withdraw(address token, uint256 amount) external onlyMultisig;
}

contract Governance {
  address[] public admins;
  uint256 public requiredSignatures; // multisig threshold
  mapping(bytes32 => uint256) public proposalVotes;
  mapping(bytes32 => bool) public executed;

  function propose(bytes32 proposalId, address target, bytes memory callData)
    external onlyAdmin;

  function vote(bytes32 proposalId) external onlyAdmin;
  function execute(bytes32 proposalId) external onlyAfterTimelock;
}

contract Timelock {
  uint256 public delay = 2 days; // all actions wait 48 hours

  mapping(bytes32 => uint256) public queuedAt; // when was action queued

  function queue(address target, bytes memory data)
    external onlyGovernance returns (bytes32 txId);

  function execute(address target, bytes memory data)
    external returns (bytes memory result)
  {
    bytes32 txId = keccak256(abi.encode(target, data));
    require(block.timestamp >= queuedAt[txId] + delay, "Timelock not expired");
    (bool ok, bytes memory result) = target.call(data);
    require(ok, "Execution failed");
  }
}