DeFi primatives for RWA

public const uint256 minimumLockupAnnouncementPeriod = 3 days;
public const uint256 maximumLockupPeriod = 3 hours;
public const uint256 minimumNonlockupPeriod = 30 days;

function lockupPeriodStartTime() external view returns (uint256 startTime);
function lockupPeriodEndTime() external view returns (uint256 endTime);
function designatedBuyer() external view returns (address buyer);

event LockupPeriodCreated(
    uint256 startTime,
    uint256 endTime
);

/// @notice Creates a lockup period during which only the designated buyer can purchase/withdraw tokens.
/// @description Swaps to buy tokens and liquidation from the pool are disabled during the lockup time for all except
/// the designated buyer. This is to prevent front running of large market purchase orders.
///
/// Fails if lockup period is currently active or the minimums/maximums are not satisfied.
///
/// @param startTime The timestamp when the lockup period starts.
/// @param endTime The timestamp when the lockup period ends.
/// @param buyer The address of the designated buyer who can purchase tokens during the lockup period.
function createLockupPeriod(
    uint256 startTime,
    uint256 endTime,
    address buyer
) external onlyRole(ADMIN_ROLE);

// ... remaining functions are a normal DEX interface ...

public const uint256 minimumCrowdsalePeriod = 7 days;
public const uint256 maximumCrowdsalePeriod = 90 days;
public const uint256 finalizationPeriod = 7 days;

function wasCrowdsaleSuccessful(uint256 crowdsaleId) external view returns (bool successful);

event CrowdsaleScheduled(
    uint256 indexed crowdsaleId,
    uint256 startTime,
    uint256 endTime,
    ERC20 tokenForSale,
    ERC20 paymentToken,
    uint256 pricePerSaleTokenEE18
);

event CrowdsaleParticipation(
    uint256 indexed crowdsaleId,
    address indexed participant,
    uint256 amountOfSaleTokensPurchased,
    uint256 amountOfPaymentTokensSpent
);

event CrowdsaleFinalized(
    uint256 indexed crowdsaleId,
    bool successful
);

/// @notice Starts a crowdsale period during which transfers are only allowed to/from the allow list.
/// @param startTime The timestamp when the crowdsale starts.
/// @param endTime The timestamp when the crowdsale ends.
/// @param tokenForSale The ERC20 token being sold in the crowdsale.
/// @param paymentToken The ERC20 token used for payment in the crowdsale.
/// @param pricePerSaleTokenEE18 The price per sale token, expressed in payment tokens with 18 decimals.
/// @dev Fails if the crowdsale period is currently active or the minimums/maximums are not satisfied.
function scheduleCrowdsale(
    uint256 startTime,
    uint256 endTime,
    ERC20 tokenForSale,
    ERC20 paymentToken,
    uint256 pricePerSaleTokenEE18
) external onlyRole(ADMIN_ROLE);

/// @notice Participates in an active crowdsale by purchasing sale tokens with payment tokens.
/// @param crowdsaleId The identifier of the crowdsale to participate in.
/// @param amountOfSaleTokensToPurchase The amount of sale tokens the participant wishes to purchase.
/// @dev Fails if the crowdsale is not active, if there are insufficient payment tokens,
/// or if the purchase exceeds the available sale tokens. Marks as finalized if full allocation reached.
function participateInCrowdsale(
    uint256 crowdsaleId,
    uint256 amountOfSaleTokensToPurchase
) external; // Be sure to calculate dust payments correctly at the end!

/// @notice Withdraws purchased sale tokens after the crowdsale has finalized or original tokens if unsuccessful.
function withdraw(uint256 crowdsaleId, address participant) external;

address public crowdsaleContract;
uint256 public crowsaleId;
bool public transfersLockedForCrowdsale = true;

/// @notice Overrides the standard transfer function to enforce crowdsale transfer restrictions.
/// @param to The address to transfer tokens to.
/// @param amount The amount of tokens to transfer.
/// @dev If transfers are locked for crowdsale, only allow transfers to/from addresses on the allow list.
function transfer(address to, uint256 amount) public override returns (bool) {
    if (transfersLockedForCrowdsale) {
        require(
            isAddressOnAllowList(msg.sender) || isAddressOnAllowList(to),
            "Transfers are locked for crowdsale; only allowed to/from allow list addresses."
        );
    }
    return super.transfer(to, amount);
}

/// @notice Sets the crowdsale contract address and ID for transfer unlocking.
/// @param _crowdsaleContract The address of the crowdsale contract.
/// @param _crowdsaleId The identifier of the crowdsale.
/// @dev Can only be called once by an admin role.
function setCrowdsaleContract(address _crowdsaleContract, uint256 _crowdsaleId) external onlyRole(ADMIN_ROLE) {
    if (crowdsaleContract != address(0)) {
        revert("Crowdsale contract already set");
    }
    crowdsaleContract = _crowdsaleContract;
    crowsaleId = _crowdsaleId;
}

/// @notice Unlocks transfers after a successful crowdsale.
/// @dev Anybody can call this function, but it will only succeed if the crowdsale was successful.
function unlockTransfersAfterCrowdsale() external {
    require(crowdsaleContract != address(0), "Crowdsale contract not set");
    ICrowdsale crowdsale = ICrowdsale(crowdsaleContract);
    require(crowdsale.wasCrowdsaleSuccessful(crowsaleId), "Crowdsale was not successful");
    transfersLockedForCrowdsale = false;
}