金融供应链智能合约 -- 智能合约实例

迈不过友情╰ 2023-10-14 14:07 53阅读 0赞

#### 前提 ####

Ownable:监管者合约,有一个函数能转让监管者。

SupplyChainFin:供应链金融合约,银行、公司信息上链，公司和银行之间的转账。

发票：记录者交易双方和交易金额等的一种记录数据。如:我在超市买了一瓶水,超市给我开了一张发票。

#### Ownable ####

// SPDX-License-Identifier: MIT
    pragma solidity >=0.4 <=0.9;
    
    /*
    *@title Ownable
    *@dev 
    */
    contract Ownable{
        
        address public owner; // 监管者
    
        event OwnershipTransferred( // 监管者转让结构体
            address indexed priviousOwner, // indexed表名可以被索引
            address indexed newOwner
        );
    
        constructor() {
            owner = msg.sender;
        }
        
        // 判断用户是否是监管者
        modifier onlyOwner(){
            require(msg.sender == owner,"You cannot owner!");
            _;
        }
    
        // 转让所有权,必须是原先监管者转让
        function transferOwnership(address newOwner) public   onlyOwner{
            require(newOwner != owner && newOwner != address(0),"newOwner cannot be empty and equal to the priviousOwner");
            emit OwnershipTransferred(owner, newOwner);
            owner = newOwner;
    
        }
    
        
    
    }

#### SupplyChainFin ####

// SPDX-License-Identifier: MIT
    pragma solidity >=0.4 <=0.9;
    import "./Ownable.sol";
    
    /**
    *@title SuppluChainFin
    *@dev
    */
    contract SupplyChainFin is Ownable{
    
        // 监管者信息结构体
        struct Supervisor{
            string supervisorName; 
            address supervisorAddress;
        }
    
        // 公司信息结构体
        struct Company{
            string companyName;
            address companyAddress;
            uint creditAsset;
            uint[] acceptReceiptIndex;
            uint[] sendReceiptIndex;
        }
        // 银行信息结构体
        struct Bank{
            string bankName;
            address bankAddress;
            uint creditAsset;
            uint[] acceptReceiptIndex;
            uint[] sendReceiptIndex;
        }
    
        // 数字发票收据信息
         struct Receipt {
            address senderAddress; 
            address accepterAddress;
            uint8 receiptType; // 发票类型
            uint8 transferType; // 转账类型
            uint amount; // 交易额
        }
    
        // 公司的map ,用于快速搜索
        mapping(address => Company) companyMap;
    
        // 银行map
        mapping (address =>Bank) bankMap;
    
        // 发票的map
        mapping (uint => Receipt) receiptMap;
    
        //监管者实体
        Supervisor public supervisor;
    
        // 公司地址的数组
        address[] public companies;
    
        // 银行地址的数组
        address[] public banks;
    
        //数组发票索引
        uint public receiptIndex;
    
        constructor(string memory name){
            supervisor = Supervisor(name,msg.sender); // 初始化监管者信息
        }
    
    
        // 将公司信息添加到智能合约中
        function addCompany(
            string memory name,
            address companyAddress
        )public payable  returns(bool){
            // 初始化公司结构体
            // 添加到公司map
            // 添加到公司数组
            Company memory newCompany = Company(
                name,
                companyAddress,
                msg.value,
                new uint[](0),
                new uint[](0)
            );
            companyMap[companyAddress] = newCompany;
            companies.push(companyAddress);
            return true;
        }
    
        // 获取公司信息
        function getCompany(
            address companyAddress
        ) public view  returns(string memory,address,uint,uint[] memory,uint[] memory){
    
            // 用地址拿出公司结构体
            // 将需要的数据一起返回
            Company memory company = companyMap[companyAddress];
            return (
                company.companyName,
                company.companyAddress,
                company.creditAsset,
                company.acceptReceiptIndex,
                company.sendReceiptIndex
            );
        }
    
        // 添加银行信息上链
        function addBank(
            string memory bankName,
            address bankAddress
        ) public payable  returns(bool){
            Bank memory newBank;
            newBank.bankName = bankName;
            newBank.bankAddress = bankAddress;
            newBank.creditAsset = msg.value;
            bankMap[bankAddress] = newBank;
            banks.push(bankAddress);
            return true;
        }
    
    
        // 获取银行信息
        function getBank(
            address bankAddress
        ) public view  returns(string memory,address,uint,uint[] memory,uint[] memory){
            Bank memory bank = bankMap[bankAddress];
            return (
                bank.bankName,
                bank.bankAddress,
                bank.creditAsset,
                bank.acceptReceiptIndex,
                bank.sendReceiptIndex
            );
        }
    
        // 获取公司全部地址
        function getAllCompanyAddress() public view returns(address[] memory){
            return companies;
        }
    
        // 获取银行全部地址
        function getAllBankAddress() public view returns(address[] memory){
            return banks;
        }
    
        // 获取凭证
        function getRecipt(
            uint index
        )public view returns(address,address,uint8,uint8,uint){
            Receipt memory receipt = receiptMap[index];
            return (
                receipt.senderAddress,
                receipt.accepterAddress,
                receipt.receiptType,
                receipt.transferType,
                receipt.amount
            );
        }
    
        //存证交易
        // receiptType: 发票类型(存证、现金)
        //1: 交易类型为存证
        //2：交易类型为现金
        // transferType: 交易类型
        //1: 银行转账给公司
        //2: 公司与公司间转账
        //3: 公司转账给银行
    
        // 银行向公司交易(公司颁布凭证):
        function bankToCompanyReceipt(
            address senderAddress, // 凭证发送方
            address accepterAddress, // 凭证接受方
            uint amount, // 交易额
            uint8 receiptType // 凭证类型
        ) public returns(uint){
            // 银行转账给公司,银行是发票接受者，只有银行同意要发票，这笔交易才能执行
            require(msg.sender == accepterAddress,"The function caller must be accper");
            // 拿出银行、公司结构体
            Company memory company = companyMap[senderAddress];
            Bank memory bank = bankMap[accepterAddress];
            // 判断公司银行是否存在
            if(keccak256(bytes(bank.bankName)) == keccak256(bytes(""))){
                return 404001;
            }
    
            if(keccak256(bytes(company.companyName)) == keccak256(bytes(""))){
                return 404002;
            }
            
            // 判断银行资产是否小于转账额
            if(bank.creditAsset < amount){
                return 500001;
            }
    
            // 初始化凭证
            Receipt memory newReceipt = Receipt(
                senderAddress,
                accepterAddress,
                receiptType,
                1,
                amount
            );
            // 发票索引 + 1
            receiptIndex += 1;
            // 根据转账额,相互的 +-
            companyMap[accepterAddress].creditAsset += amount;
            bankMap[senderAddress].creditAsset -= amount;
            // 存凭证索引,这样我们拿到公司或银行信息,拿到发票索引,在拿到发票结构体
            receiptMap[receiptIndex] = newReceipt;
            companyMap[accepterAddress].sendReceiptIndex.push(receiptIndex);
            bankMap[senderAddress].acceptReceiptIndex.push(receiptIndex);
            return 200;
        }
    
        //公司向公司交易(接受钱的公司需要颁布凭证)
    
        function companyToCompanyReceipt(
            address senderAddress,
            address accepterAddress,
            uint amount,
            uint8 receiptType
        ) public  returns(uint){
            require(msg.sender == accepterAddress);
    
            Company memory senderCompany = companyMap[senderAddress];
            Company memory accepterCompany = companyMap[accepterAddress];
    
            if (keccak256(bytes(senderCompany.companyName)) == keccak256(bytes(""))) {
                return 404001;
            }
    
            //确认接收公司存在
            if (keccak256(bytes(accepterCompany.companyName)) == keccak256(bytes(""))) {
                return 404002;
            }
    
            //如果存证接收的公司资产小于存证数额，那么就不能交易发送存证
            if (accepterCompany.creditAsset < amount) {
                return 500001;
            }
    
            //创建存证
            Receipt memory newReceipt = Receipt(
                senderAddress,
                accepterAddress,
                receiptType,
                2,
                amount
            );
            receiptIndex += 1;
            //记录存证（存证Map，公司Map对应地址的发送和接收存证列表）
            receiptMap[receiptIndex] = newReceipt;
            companyMap[senderAddress].sendReceiptIndex.push(receiptIndex);
            companyMap[accepterAddress].acceptReceiptIndex.push(receiptIndex);
    
            companyMap[senderAddress].creditAsset += amount;
            companyMap[accepterAddress].creditAsset -= amount;
            return 200;
    
        }
        
        //公司与银行交易(银行颁布凭证)
        function companyToBankReceipt(
            address senderAddress,
            address accepterAddress,
            uint amount,
            uint8 receiptType
        ) public  returns (uint) {
         
            require(msg.sender == accepterAddress);
    
            Bank memory bank = bankMap[senderAddress];
            Company memory accepterCompany = companyMap[accepterAddress];
    
            //确认发送公司存在
            if (keccak256(bytes(bank.bankName)) == keccak256(bytes(""))) {
                return 404001;
            }
    
            //确认接收公司存在
            if (keccak256(bytes(accepterCompany.companyName)) == keccak256(bytes(""))) {
                return 404002;
            }   
    
            //如果存证接收的公司资产小于存证数额，那么就不能交易发送存证
            if (accepterCompany.creditAsset < amount) {
                return 500001;
            }
    
            //创建存证
            Receipt memory newReceipt = Receipt(
                senderAddress,
                accepterAddress,
                receiptType,
                3,
                amount
            );
            receiptIndex += 1;
            //记录存证（存证Map，公司Map对应地址的发送和接收存证列表）
            receiptMap[receiptIndex] = newReceipt;
            bankMap[senderAddress].sendReceiptIndex.push(receiptIndex);
            companyMap[accepterAddress].acceptReceiptIndex.push(receiptIndex);
    
            bankMap[senderAddress].creditAsset += amount;
            companyMap[accepterAddress].creditAsset -= amount;
            return 200;
        }
    
    
    
    
    
    
    
    }