Smart Contract Templates

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

import "@bloklab/contracts/token/SecurityToken.sol";
import "@bloklab/contracts/compliance/TransferRestrictions.sol";

contract MySecurityToken is SecurityToken {
    constructor(
        string memory name,
        string memory symbol,
        uint256 totalSupply
    ) SecurityToken(name, symbol, totalSupply) {
        // Initialize your token here
    }
    
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        super._beforeTokenTransfer(from, to, amount);
        // Add custom compliance checks
    }
}

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

import "@bloklab/contracts/token/AssetToken.sol";
import "@bloklab/contracts/ownership/AssetOwnership.sol";

contract RealEstateToken is AssetToken {
    struct Property {
        string propertyId;
        string location;
        uint256 valuation;
        bool verified;
    }
    
    mapping(uint256 => Property) public properties;
    
    constructor() AssetToken("Real Estate Token", "RET") {}
    
    function tokenizeProperty(
        string memory propertyId,
        string memory location,
        uint256 valuation,
        uint256 tokenSupply
    ) external onlyOwner {
        uint256 tokenId = _nextTokenId();
        properties[tokenId] = Property(propertyId, location, valuation, false);
        _mint(msg.sender, tokenId, tokenSupply, "");
    }
}

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

import "@bloklab/contracts/vesting/TokenVesting.sol";

contract TeamTokenVesting is TokenVesting {
    mapping(address => VestingSchedule) public vestingSchedules;
    
    struct VestingSchedule {
        uint256 totalAmount;
        uint256 cliffDuration;
        uint256 vestingDuration;
        uint256 startTime;
        uint256 releasedAmount;
    }
    
    constructor(IERC20 _token) TokenVesting(_token) {}
    
    function createVestingSchedule(
        address beneficiary,
        uint256 totalAmount,
        uint256 cliffDuration,
        uint256 vestingDuration
    ) external onlyOwner {
        vestingSchedules[beneficiary] = VestingSchedule({
            totalAmount: totalAmount,
            cliffDuration: cliffDuration,
            vestingDuration: vestingDuration,
            startTime: block.timestamp,
            releasedAmount: 0
        });
    }
}

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

import "@bloklab/contracts/compliance/ComplianceRules.sol";
import "@bloklab/contracts/registry/InvestorRegistry.sol";

contract TokenCompliance is ComplianceRules {
    InvestorRegistry public investorRegistry;
    
    mapping(address => bool) public accreditedInvestors;
    uint256 public maxInvestors = 500;
    uint256 public currentInvestorCount;
    
    constructor(address _investorRegistry) {
        investorRegistry = InvestorRegistry(_investorRegistry);
    }
    
    function checkTransferCompliance(
        address from,
        address to,
        uint256 amount
    ) external view override returns (bool) {
        // Check investor accreditation
        if (!accreditedInvestors[to] && to != address(0)) {
            return false;
        }
        
        // Check investor limit
        if (balanceOf(to) == 0 && currentInvestorCount >= maxInvestors) {
            return false;
        }
        
        return true;
    }
}