📋InvestmentAgreement

Contract template of Investment Agreement

Name	InvestmentAgreement
Address	0xA78034367C746c220D13293cBAb17be6d7FB4b0a
Dependent Contract	IInvestmentAgreement, SigPage, SwapsRepo, DealsRepo, ISigPage

API：

Source Code:

InvestmentAgreement

// SPDX-License-Identifier: UNLICENSED

/* *
 * Copyright (c) 2021-2023 LI LI @ JINGTIAN & GONGCHENG.
 *
 * This WORK is licensed under ComBoox SoftWare License 1.0, a copy of which 
 * can be obtained at:
 *         [https://github.com/paul-lee-attorney/comboox]
 *
 * THIS WORK IS PROVIDED ON AN "AS IS" BASIS, WITHOUT 
 * WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED 
 * TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. IN NO 
 * EVENT SHALL ANY CONTRIBUTOR BE LIABLE TO YOU FOR ANY DAMAGES.
 *
 * YOU ARE PROHIBITED FROM DEPLOYING THE SMART CONTRACTS OF THIS WORK, IN WHOLE 
 * OR IN PART, FOR WHATEVER PURPOSE, ON ANY BLOCKCHAIN NETWORK THAT HAS ONE OR 
 * MORE NODES THAT ARE OUT OF YOUR CONTROL.
 * */

pragma solidity ^0.8.8;


import "../../common/components/SigPage.sol";

import "./IInvestmentAgreement.sol";

contract InvestmentAgreement is IInvestmentAgreement, SigPage {
    using DealsRepo for DealsRepo.Repo;
    using SigsRepo for SigsRepo.Page;

    DealsRepo.Repo private _repo;

    //#################
    //##  Write I/O  ##
    //#################

    function addDeal(
        bytes32 sn,
        uint buyer,
        uint groupOfBuyer,
        uint paid,
        uint par
    ) external attorneyOrKeeper {
        _repo.addDeal(sn, buyer, groupOfBuyer, paid, par);
        // emit AddDeal(seqOfDeal);
    }

    function regDeal(DealsRepo.Deal memory deal) 
        public attorneyOrKeeper returns(uint16 seqOfDeal) 
    {
        seqOfDeal = _repo.regDeal(deal);

        if (!isFinalized()) {
            if (deal.head.seller != 0) _sigPages[0].addBlank(false, seqOfDeal, deal.head.seller);
            _sigPages[0].addBlank(true, seqOfDeal, deal.body.buyer);
        } else {
            if (deal.head.seller != 0) _sigPages[1].addBlank(false, seqOfDeal, deal.head.seller);
            _sigPages[1].addBlank(true, seqOfDeal, deal.body.buyer);
        } 
        emit RegDeal(deal.head.seqOfDeal);
    }

    function delDeal(uint256 seq) external onlyAttorney {

        DealsRepo.Deal memory deal = _repo.deals[seq];

        if (_repo.delDeal(seq)) {
            if (deal.head.seller != 0) {
                _sigPages[0].removeBlank(deal.head.seqOfDeal, deal.head.seller);
            }
            _sigPages[0].removeBlank(deal.head.seqOfDeal, deal.body.buyer);
        }
    }

    function lockDealSubject(uint256 seq) external onlyKeeper returns (bool flag) {
        flag = _repo.lockDealSubject(seq);
    }

    function releaseDealSubject(uint256 seq)
        external onlyDK returns (bool flag)
    {
        flag = _repo.releaseDealSubject(seq);
    }

    function clearDealCP(
        uint256 seq,
        bytes32 hashLock,
        uint closingDeadline
    ) external onlyDK {
        _repo.clearDealCP(seq, hashLock, closingDeadline);
        emit ClearDealCP(seq, hashLock, closingDeadline);
    }

    function closeDeal(uint256 seq, string memory hashKey)
        external
        onlyDK
        returns (bool flag)
    {        
        flag = _repo.closeDeal(seq, hashKey);
        emit CloseDeal(seq, hashKey);
    }

    function directCloseDeal(uint256 seq)
        external
        onlyDK
        returns (bool flag)
    {        
        flag = _repo.directCloseDeal(seq);
        emit CloseDeal(seq, '');
    }

    function terminateDeal(uint256 seqOfDeal) 
        external onlyKeeper returns(bool flag)
    {
        flag = _repo.terminateDeal(seqOfDeal);
        emit TerminateDeal(seqOfDeal);
    }

    function takeGift(uint256 seq)
        external onlyKeeper returns (bool flag)
    {
        flag = _repo.takeGift(seq);
        emit CloseDeal(seq, "0");
    }

    function finalizeIA() external {
        _repo.calTypeOfIA();
        lockContents();
    }

    // ==== Swap ====

    function createSwap (
        uint seqOfMotion,
        uint seqOfDeal,
        uint paidOfTarget,
        uint seqOfPledge,
        uint caller
    ) external onlyKeeper returns(SwapsRepo.Swap memory swap) {
        

        swap = _repo.createSwap(seqOfMotion, seqOfDeal, paidOfTarget, 
            seqOfPledge, caller, _gk.getROS(), _gk.getGMM());

        emit CreateSwap(seqOfDeal, SwapsRepo.codifySwap(swap));
    }

    function payOffSwap(
        uint seqOfMotion,
        uint seqOfDeal,
        uint seqOfSwap,
        uint msgValue,
        uint centPrice
    ) external onlyKeeper returns(SwapsRepo.Swap memory swap){
        swap = _repo.payOffSwap(seqOfMotion, seqOfDeal, 
            seqOfSwap, msgValue, centPrice, _gk.getGMM());

        emit PayOffSwap(seqOfDeal, seqOfSwap, msgValue);
    }

    function terminateSwap(
        uint seqOfMotion,
        uint seqOfDeal,
        uint seqOfSwap
    ) external onlyKeeper returns (SwapsRepo.Swap memory swap){
        swap = _repo.terminateSwap(seqOfMotion, seqOfDeal, 
            seqOfSwap, _gk.getGMM());
        emit TerminateSwap(seqOfDeal, seqOfSwap);        
    }

    function payOffApprovedDeal(
        uint seqOfDeal,
        uint msgValue,
        // uint centPrice,
        uint caller
    ) external returns (bool flag){
        flag = _repo.payOffApprovedDeal(seqOfDeal, caller);
        emit PayOffApprovedDeal(seqOfDeal, msgValue);
    }

    function requestPriceDiff(
        uint seqOfDeal,
        uint seqOfShare
    ) external onlyKeeper {
        _repo.requestPriceDiff(seqOfDeal, seqOfShare);
    }

    //  #################################
    //  ##       查询接口               ##
    //  ################################

    function getTypeOfIA() external view returns (uint8) {
        return _repo.getTypeOfIA();
    }

    // function counterOfDeal() public view returns (uint16) {
    //     return _repo.counterOfDeal();
    // }

    // function counterOfClosedDeal() public view returns (uint16) {
    //     return _repo.counterOfClosedDeal();
    // }

    // function isDeal(uint256 seqOfDeal) public view returns (bool) {
    //     return _repo.isDeal(seqOfDeal);
    // }
    
    function getDeal(uint256 seqOfDeal) external view returns (DealsRepo.Deal memory)
    {
        return _repo.getDeal(seqOfDeal);
    }

    function getSeqList() external view returns (uint[] memory) {
        return _repo.getSeqList();
    }

    // ==== Swap ====

    // function counterOfSwaps(uint seqOfDeal)
    //     external view returns (uint16)
    // {
    //     return _repo.counterOfSwaps(seqOfDeal);
    // }

    // function sumPaidOfTarget(uint seqOfDeal)
    //     external view returns (uint64)
    // {
    //     return _repo.sumPaidOfTarget(seqOfDeal);
    // }

    function getSwap(uint seqOfDeal, uint256 seqOfSwap)
        external view returns (SwapsRepo.Swap memory)
    {
        return _repo.getSwap(seqOfDeal, seqOfSwap);
    }

    function getAllSwaps(uint seqOfDeal)
        external view returns (SwapsRepo.Swap[] memory )
    {
        return _repo.getAllSwaps(seqOfDeal);
    }

    function allSwapsClosed(uint seqOfDeal)
        external view returns (bool)
    {
        return _repo.allSwapsClosed(seqOfDeal);
    } 

    // ==== Value ====

    function checkValueOfSwap(uint seqOfDeal, uint seqOfSwap)
        external view returns(uint)
    {
        return _repo.checkValueOfSwap(seqOfDeal, seqOfSwap, _gk.getCentPrice());
    }

    function checkValueOfDeal(uint seqOfDeal)
        external view returns (uint)
    {
        return _repo.checkValueOfDeal(seqOfDeal, _gk.getCentPrice());
    }
}

IInvestmentAgreement

// SPDX-License-Identifier: UNLICENSED

/* *
 * Copyright (c) 2021-2023 LI LI @ JINGTIAN & GONGCHENG.
 *
 * This WORK is licensed under ComBoox SoftWare License 1.0, a copy of which 
 * can be obtained at:
 *         [https://github.com/paul-lee-attorney/comboox]
 *
 * THIS WORK IS PROVIDED ON AN "AS IS" BASIS, WITHOUT 
 * WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED 
 * TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. IN NO 
 * EVENT SHALL ANY CONTRIBUTOR BE LIABLE TO YOU FOR ANY DAMAGES.
 *
 * YOU ARE PROHIBITED FROM DEPLOYING THE SMART CONTRACTS OF THIS WORK, IN WHOLE 
 * OR IN PART, FOR WHATEVER PURPOSE, ON ANY BLOCKCHAIN NETWORK THAT HAS ONE OR 
 * MORE NODES THAT ARE OUT OF YOUR CONTROL.
 * */

pragma solidity ^0.8.8;

import "../../../lib/SwapsRepo.sol";
import "../../../lib/DealsRepo.sol";

import "../../common/components/ISigPage.sol";

interface IInvestmentAgreement is ISigPage {

    //##################
    //##    Event     ##
    //##################

    event RegDeal(uint indexed seqOfDeal);

    event ClearDealCP(
        uint256 indexed seq,
        bytes32 indexed hashLock,
        uint indexed closingDeadline
    );

    event CloseDeal(uint256 indexed seq, string indexed hashKey);

    event TerminateDeal(uint256 indexed seq);
    
    event CreateSwap(uint seqOfDeal, bytes32 snOfSwap);

    event PayOffSwap(uint seqOfDeal, uint seqOfSwap, uint msgValue);

    event TerminateSwap(uint seqOfDeal, uint seqOfSwap);

    event PayOffApprovedDeal(uint seqOfDeal, uint msgValue);

    //##################
    //##  Write I/O  ##
    //##################

    // ======== InvestmentAgreement ========

    function addDeal(
        bytes32 sn,
        uint buyer,
        uint groupOfBuyer,
        uint paid,
        uint par
    ) external;

    function regDeal(DealsRepo.Deal memory deal) external returns(uint16 seqOfDeal);

    function delDeal(uint256 seq) external;

    function lockDealSubject(uint256 seq) external returns (bool flag);

    function releaseDealSubject(uint256 seq) external returns (bool flag);

    function clearDealCP( uint256 seq, bytes32 hashLock, uint closingDeadline) external;

    function closeDeal(uint256 seq, string memory hashKey)
        external returns (bool flag);

    function directCloseDeal(uint256 seq) external returns (bool flag);

    function terminateDeal(uint256 seqOfDeal) external returns(bool);

    function takeGift(uint256 seq) external returns(bool);

    function finalizeIA() external;

    // ==== Swap ====

    function createSwap (
        uint seqOfMotion,
        uint seqOfDeal,
        uint paidOfTarget,
        uint seqOfPledge,
        uint caller
    ) external returns(SwapsRepo.Swap memory swap);

    function payOffSwap(
        uint seqOfMotion,
        uint seqOfDeal,
        uint seqOfSwap,
        uint msgValue,
        uint centPrice
    ) external returns(SwapsRepo.Swap memory swap);

    function terminateSwap(
        uint seqOfMotion,
        uint seqOfDeal,
        uint seqOfSwap
    ) external returns (SwapsRepo.Swap memory swap);

    function payOffApprovedDeal(
        uint seqOfDeal,
        uint msgValue,
        // uint centPrice,
        uint caller
    ) external returns (bool flag);

    function requestPriceDiff(
        uint seqOfDeal,
        uint seqOfShare
    ) external;

    //  #####################
    //  ##     查询接口     ##
    //  #####################

    // ======== InvestmentAgreement ========
    function getTypeOfIA() external view returns (uint8);

    // function counterOfDeal() external view returns (uint16);

    // function counterOfClosedDeal() external view returns (uint16);

    // function isDeal(uint256 seq) external view returns (bool);

    function getDeal(uint256 seq) external view returns (DealsRepo.Deal memory);

    function getSeqList() external view returns (uint[] memory);

    // ==== Swap ====

    // function counterOfSwaps(uint seqOfDeal)
    //     external view returns (uint16);

    // function sumPaidOfTarget(uint seqOfDeal)
    //     external view returns (uint64);

    function getSwap(uint seqOfDeal, uint256 seqOfSwap)
        external view returns (SwapsRepo.Swap memory);

    function getAllSwaps(uint seqOfDeal)
        external view returns (SwapsRepo.Swap[] memory);

    function allSwapsClosed(uint seqOfDeal)
        external view returns (bool);

    function checkValueOfSwap(uint seqOfDeal, uint seqOfSwap)
        external view returns(uint);

    function checkValueOfDeal(uint seqOfDeal)
        external view returns (uint);

}