📘RegisterOfPledges

Register of Pledges

Name	RegisterOfPledges
Address	0xdB8eE40f0e7930C5E8e73406707D11C5cEf0E7B4
Dependent Contract	IRegisterOfPledges, AccessControl, PledgesRepo

API：

Source Code:

RegisterOfPledges

// 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 "./IRegisterOfPledges.sol";

import "../../common/access/AccessControl.sol";

contract RegisterOfPledges is IRegisterOfPledges, AccessControl {
    using PledgesRepo for PledgesRepo.Repo;
    using PledgesRepo for PledgesRepo.Pledge;

    PledgesRepo.Repo private _repo;

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

    function createPledge(
        bytes32 snOfPld,
        uint paid,
        uint par,
        uint guaranteedAmt,
        uint execDays
    ) external onlyDK returns(PledgesRepo.Head memory head){
        head = _repo.createPledge(
            snOfPld,
            paid,
            par,
            guaranteedAmt,
            execDays
        );

        emit CreatePledge(
            head.seqOfShare,
            head.seqOfPld,
            head.creditor,
            paid,
            par
        );
    }

    function issuePledge(
        PledgesRepo.Head memory head,
        uint paid,
        uint par,
        uint guaranteedAmt,
        uint execDays
    ) external onlyKeeper returns(PledgesRepo.Head memory regHead)
    {
        regHead = _repo.issuePledge(
            head, 
            paid,
            par,
            guaranteedAmt,
            execDays
        );

        emit CreatePledge(
            head.seqOfShare,
            head.seqOfPld,
            head.creditor,
            paid,
            par
        );
    }

    function regPledge(
        PledgesRepo.Pledge memory pld
    ) external onlyKeeper returns(PledgesRepo.Head memory head){
        head = _repo.regPledge(pld);

        emit CreatePledge(
            pld.head.seqOfShare, 
            head.seqOfPld, 
            pld.head.creditor,
            pld.body.paid, 
            pld.body.par 
        );
    }

    // ==== Transfer Pledge ====

    function transferPledge(
        uint256 seqOfShare,
        uint256 seqOfPld,
        uint buyer,
        uint amt,
        uint caller
    ) external onlyKeeper returns (PledgesRepo.Pledge memory newPld)
    {
        require(buyer > 0, "ROP.transferPld: zero buyer");

        newPld = _repo.splitPledge(seqOfShare, seqOfPld, buyer, amt, caller);

        emit TransferPledge(
            newPld.head.seqOfShare, 
            seqOfPld,
            newPld.head.seqOfPld, 
            newPld.head.creditor,
            newPld.body.paid, 
            newPld.body.par 
        );
    }

    // ==== Update Pledge ====

    function refundDebt(
        uint256 seqOfShare,
        uint256 seqOfPld,
        uint amt,
        uint caller
    ) external onlyKeeper returns (PledgesRepo.Pledge memory newPld)
    {
        newPld = _repo.splitPledge(seqOfShare, seqOfPld, 0, amt, caller);

        emit RefundDebt(seqOfShare, seqOfPld, amt);
    }

    function extendPledge(
        uint256 seqOfShare,
        uint256 seqOfPld,
        uint extDays,
        uint caller
    ) external onlyKeeper {
        _repo.pledges[seqOfShare][seqOfPld].extendPledge(extDays, caller);
        emit ExtendPledge(seqOfShare, seqOfPld, extDays);
    }

    // ==== Lock/Release/Exec/Revoke ====

    function lockPledge(
        uint256 seqOfShare,
        uint256 seqOfPld,
        bytes32 hashLock,
        uint caller
    ) external onlyKeeper {
        _repo.pledges[seqOfShare][seqOfPld].lockPledge(hashLock, caller);
        emit LockPledge(seqOfShare, seqOfPld, hashLock);
    }

    function releasePledge(
        uint256 seqOfShare, 
        uint256 seqOfPld, 
        string memory hashKey
    ) external onlyKeeper returns (uint64) {
        PledgesRepo.Pledge storage pld = _repo.pledges[seqOfShare][seqOfPld];
        pld.releasePledge(hashKey);   
        emit ReleasePledge(seqOfShare, seqOfPld, hashKey);
        return pld.body.paid;
    }

    function execPledge(uint256 seqOfShare, uint256 seqOfPld, uint caller)
        external onlyKeeper 
    {
        _repo.pledges[seqOfShare][seqOfPld].execPledge(caller);
        emit ExecPledge(seqOfShare, seqOfPld);
    }

    function revokePledge(uint256 seqOfShare, uint256 seqOfPld, uint caller)
        external onlyKeeper {
        _repo.pledges[seqOfShare][seqOfPld].revokePledge(caller);
        emit RevokePledge(seqOfShare, seqOfPld);
    }

    //##################
    //##   Read       ##
    //##################

    function counterOfPledges(uint256 seqOfShare) 
        external view returns (uint16) 
    {
        return _repo.counterOfPld(seqOfShare);
    }

    function isPledge(uint256 seqOfShare, uint256 seqOfPledge) 
        external view returns (bool) 
    {
        return _repo.isPledge(seqOfShare, seqOfPledge);
    }

    function getSNList() external view returns(bytes32[] memory)
    {
        return _repo.getSNList();
    }

    function getPledge(uint256 seqOfShare, uint256 seqOfPld)
        external view returns (PledgesRepo.Pledge memory)
    {
        return _repo.getPledge(seqOfShare, seqOfPld);
    }

    function getPledgesOfShare(uint256 seqOfShare) 
        external view returns (PledgesRepo.Pledge[] memory) 
    {
        return _repo.getPledgesOfShare(seqOfShare);
    }

    function getAllPledges() external view 
        returns (PledgesRepo.Pledge[] memory)
    {
        return _repo.getAllPledges();
    }

}

IRegisterOfPledges

// 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/PledgesRepo.sol";

interface IRegisterOfPledges {

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

    event CreatePledge(
        uint256 indexed seqOfShare,
        uint256 indexed seqOfPld,
        uint256 creditor,
        uint256 indexed paid,
        uint256 par
    );

    event TransferPledge(
        uint256 indexed seqOfShare,
        uint256 indexed seqOfPld,
        uint256 indexed newSeqOfPld,
        uint256 buyer,
        uint256 paid,
        uint256 par
    );

    event RefundDebt(
        uint256 indexed seqOfShare,
        uint256 indexed seqOfPld,
        uint256 indexed refundAmt
    );

    event ExtendPledge(
        uint256 indexed seqOfShare,
        uint256 indexed seqOfPld,
        uint256 indexed extDays
    );

    event LockPledge(uint256 indexed seqOfShare, uint256 indexed seqOfPld, bytes32 indexed hashLock);

    event ReleasePledge(uint256 indexed seqOfShare, uint256 indexed seqOfPld, string indexed hashKey);

    event ExecPledge(uint256 indexed seqOfShare, uint256 indexed seqOfPld);

    event RevokePledge(uint256 indexed seqOfShare, uint256 indexed seqOfPld);

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

    function createPledge(
        bytes32 snOfPld,
        uint paid,
        uint par,
        uint guaranteedAmt,
        uint execDays
    ) external returns(PledgesRepo.Head memory head);

    function issuePledge(
        PledgesRepo.Head memory head,
        uint paid,
        uint par,
        uint guaranteedAmt,
        uint execDays
    ) external returns(PledgesRepo.Head memory regHead);

    function regPledge(
        PledgesRepo.Pledge memory pld
    ) external returns(PledgesRepo.Head memory head);

    function transferPledge(
        uint256 seqOfShare,
        uint256 seqOfPld,
        uint buyer,
        uint amt,
        uint caller
    ) external returns (PledgesRepo.Pledge memory newPld);

    function refundDebt(
        uint256 seqOfShare,
        uint256 seqOfPld,
        uint amt,
        uint caller
    ) external returns (PledgesRepo.Pledge memory newPld);

    function extendPledge(
        uint256 seqOfShare,
        uint256 seqOfPld,
        uint extDays,
        uint caller
    ) external;

    // ==== Lock/Release/Exec/Revoke ====

    function lockPledge(
        uint256 seqOfShare,
        uint256 seqOfPld,
        bytes32 hashLock,
        uint caller
    ) external;

    function releasePledge(uint256 seqOfShare, uint256 seqOfPld, string memory hashKey)
        external returns (uint64);

    function execPledge(
        uint seqOfShare, 
        uint256 seqOfPld,
        uint caller
    ) external;

    function revokePledge(uint256 seqOfShare, uint256 seqOfPld, uint caller)
        external; 

    //##################
    //##    Read      ##
    //##################

    function counterOfPledges(uint256 seqOfShare) 
        external view returns (uint16);

    function isPledge(uint256 seqOfShare, uint256 seqOfPld) 
        external view returns (bool);

    function getSNList() external view
        returns(bytes32[] memory);

    function getPledge(uint256 seqOfShare, uint256 seqOfPld)
        external view returns (PledgesRepo.Pledge memory);

    function getPledgesOfShare(uint256 seqOfShare) 
        external view returns (PledgesRepo.Pledge[] memory);

    function getAllPledges() external view 
        returns (PledgesRepo.Pledge[] memory);

}