Solidity合約:玉米生產溯源

實現思路：

首先用地址與每個結構進行映射，將關鍵信息儲存在結構體中；或者將關鍵信息在外部通過json儲存，內部儲存對應的hash值；

使用issue函數表示：玉米地中收獲足夠數量的玉米並進行記錄；

使用transfer函數表示：玉米在源產地與經銷商手中流轉，最終流轉至消費者手中；

使用getCornCount函數：查詢當前該角色所擁有的玉米數量；

使用IsInHead函數：判斷當前該角色是否為玉米源產地；

使用LeafQuery函數：消費者查詢玉米的來路，進行溯源操作；

使用NodeQueryFloor函數：經銷商查詢玉米的去路，進行商品去路調研獲取數據，以便后期進行分析；

話不多說，先上代碼：

pragma solidity ^0.4.11;

//注意一些關鍵原則
//自己不能給自己轉玉米：確保不形成自環，且無現實意義；
//每個地址代表一個角色；

contract FindCorn {
    // 三種關鍵角色 源產地 經銷商與消費者
    struct Consumer_Dealer_Origin {
        uint count;             //當前代表角色玉米總數
        //string place;           //當前代表角色地理位置信息
        //uint begin_time;        //當前代表角色獲得玉米時刻
        //uint end_time;          //當前代表角色失去玉米時刻
        
        //以上多點均為玉米溯源過程中所需信息
        //可以根據具體需求進行增減
        //重點關注整體的框架設計及信息的流轉
        address father;         //連接當前父節點
        address[] child;        //連接當前節點的子節點
    }
    
    address[] Head;            //存儲root節點信息
    mapping(address => Consumer_Dealer_Origin) identify;    //當前角色與其地址的映射關系
    
    // function GetNewNode(string placename) returns(Consumer_Dealer_Origin) {
    //     Consumer_Dealer_Origin A = new Consumer_Dealer_Origin({
    //       count : 0,
    //       place : "",
    //       begin_time : 0,
    //       end_time : 0,
           
    //       father : '0x00000000'

    //     });
    //     return A;
    // }    
    
    //收獲玉米啦，取到多少算多少
    function issue(address input,uint count) returns (string, address, uint) {
        identify[input].count = identify[input].count + count;
    //    identify[input].begin_time = nowtime;
        Head.push(input);
        return ("add corn success!",input,count);
    }    
    
    //玉米流通啦，賣玉米啦
    //地址本身不能進行玉米流通
    function transfer(address from1,address to,uint num) returns (string,bool){
        if(from1==to){
            return ("you can't transfer corn to yourself",false);
        }else if(num==0){
            return ("you can't transfer zero corn to others",false);
        }
        if(identify[from1].count>=num){
            identify[from1].count = identify[from1].count - num;
            identify[to].count = identify[to].count + num;
            
            //確定玉米流通的流向關系
            identify[from1].child.push(to);
            identify[to].father = from1;
            
            return ("add the corn success!",true);
        }
        return ("this from1 don't have enough corn!",false);
    }
    
    //查詢賬戶剩余玉米數
    function getCornCount(address query) returns (address,uint){
        return (identify[query].father, identify[query].count);
    }
    

    function IsInHead(address i) returns (bool){
        for(uint j=0;j < Head.length;j++){
            if(Head[j]==i)
                return true;
        }
        return false;
    }
    
    address []addrpath = new address[](1);
    //消費者查詢：我的玉米從哪里來
    function LeafQuery(address consumer) returns (address[]){
        addrpath.length = 0;
        addrpath[addrpath.length++]=consumer;
        while(!IsInHead(addrpath[addrpath.length-1])){
            consumer = identify[addrpath[addrpath.length-1]].father;
            addrpath[addrpath.length++]=consumer;
        }
        return addrpath;
    }
    
    //經銷商查詢：我的玉米從哪里來
    function NodeQueryCeil(address corn) returns (address[]) {
        return LeafQuery(corn);
    }
    
    //經銷商查詢：玉米去哪了
    address []queue = new address[](1);
    uint index1;
    uint index2;
    function NodeQueryFloor(address corn) returns (address[]){
        //對經銷商節點開始進行層次遍歷，查找出所有的葉子節點
        index1=0;
        index2=1;
        addrpath.length = 0;
        queue.length=0;
        queue[queue.length++]=corn;
        while(index1!=index2){
            if(identify[queue[index1]].child.length==0){
                addrpath[addrpath.length++]=queue[index1];
            }
            index2 = index2+identify[queue[index1]].child.length;
            for(uint i=0;i<identify[queue[index1]].child.length;i++){
                queue[queue.length++]=identify[queue[index1]].child[i];
            }
            index1++;
        }
        return addrpath;
    }
}    

假設0x1地址是玉米地，其中0x2、0x3、0x6都是玉米經銷商，0x4、0x5、0x7、0x8都是玉米消費者，那么他們最后的玉米流轉關系圖如下圖中的樹關系：

首先執行issue方法,給0x1地址沖入玉米，表示從玉米地收獲玉米；

Function [issue] invoking...
Invoke args:
From
0xca35b7d915458ef540ade6068dfe2f44e8fa733c
To
0xf90cfc79dda26f368da31dc0b7944d25ca9a2407
Constant
false
Payload
867904b400000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000002710
Invoke finish
Result
0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000002710000000000000000000000000000000000000000000000000000000000000001161646420636f726e207375636365737321000000000000000000000000000000
Decoded
["string: add corn success!","address: 0x1","uint256: 10000"]
TxHash
0x86930a394106caf46f2aef7d77772d51a6ba2a555a8a1bd24f148f3200cf23a1
From
0xca35b7d915458ef540ade6068dfe2f44e8fa733c
To
0xf90cfc79dda26f368da31dc0b7944d25ca9a2407

然后開始轉運玉米，包括：

1到2；1到3；2到4；2到5；3到6；6到7；7到8；

transfer方法：

 

 

Function [transfer] invoking...
Invoke args:
From
0xca35b7d915458ef540ade6068dfe2f44e8fa733c
To
0xf90cfc79dda26f368da31dc0b7944d25ca9a2407
Constant
false
Payload
beabacc8000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000064
Invoke finish
Result
0x0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000156164642074686520636f726e2073756363657373210000000000000000000000
Decoded
["string: add the corn success!","bool: true"]
TxHash
0x356356817753e1ffba1378f9b0f48e0253f56e7dadb75004c53b156b984a983e
From
0xca35b7d915458ef540ade6068dfe2f44e8fa733c
To
0xf90cfc79dda26f368da31dc0b7944d25ca9a2407

消費者開始溯源手頭的玉米流轉流程：

LeafQuery：

Function [LeafQuery] invoking...
Invoke args:
From
0xca35b7d915458ef540ade6068dfe2f44e8fa733c
To
0xf90cfc79dda26f368da31dc0b7944d25ca9a2407
Constant
false
Payload
210d7dec0000000000000000000000000000000000000000000000000000000000000008
Invoke finish
Result
0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000001
Decoded
["address[]: 0x8, 0x6, 0x3, 0x1"]
TxHash
0xd2019faf0ce53479768ed7564d2394dc2bb95a11f641bdbf93b29b3c9c927689
From
0xca35b7d915458ef540ade6068dfe2f44e8fa733c
To
0xf90cfc79dda26f368da31dc0b7944d25ca9a2407

經銷商0x3查詢玉米去哪里了：

Function [NodeQueryFloor] invoking...
Invoke args:
From
0xca35b7d915458ef540ade6068dfe2f44e8fa733c
To
0xf90cfc79dda26f368da31dc0b7944d25ca9a2407
Constant
false
Payload
ec6d9c640000000000000000000000000000000000000000000000000000000000000003
Invoke finish
Result
0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000070000000000000000000000000000000000000000000000000000000000000008
Decoded
["address[]: 0x7, 0x8"]
TxHash
0xd5d791fb4a3185aba42dfd30ec371a4e7fcfb66127ce13e3f617811c361389c7
From
0xca35b7d915458ef540ade6068dfe2f44e8fa733c
To
0xf90cfc79dda26f368da31dc0b7944d25ca9a2407

 修改后完善代碼，警告（當前代碼的數據可能是僅僅只保存在內存當中的，可能會出現丟失的情況，需要將其完善成固定存儲）

pragma solidity ^0.4.11;

//使用繼承的方式書寫合約 使得整體邏輯變清晰
contract Corn {
    //收獲玉米,向源產地對象地址產出的玉米數量進行記錄
    function harvestCorn(address input, uint count)  returns(string, address, uint){}

    //玉米流通，將玉米在不同角色中流轉的數量關系及對象關系進行記錄
    function transpartCorn(address from1, address to, uint num) returns(string, bool){}

    //獲取當前對象地址的玉米數量
    function getCornCount(address query) returns(address, uint){}

    //判斷當前對象是否屬於源產地
    function isInHead(address i) returns(bool) {}

    //從當前對象出發查詢商品來源
    function nodeQueryCeil(address corn) returns(address[]) {}

    //從當前對象出發查詢商品流向
    function nodeQueryFloor(address corn) returns(address[], address[]) {}

    //消費者查詢當前商品來源
    function leafQuery(address consumer) returns(address[]){}
}

contract FindCorn is Corn{
    // 三種關鍵角色 源產地 經銷商與消費者
    struct Consumer_Dealer_Origin {
        uint count; //當前代表角色玉米總數
        address father; //連接當前父節點
        address[] child; //連接當前節點的子節點
    }

    address[] Head; //存儲root節點信息 用來代表分片玉米地
    mapping(address => Consumer_Dealer_Origin) identify; //當前角色與其地址的映射關系

    //收獲玉米啦 對收獲的玉米進行數量記錄，同時所有收獲的玉米屬於同一個生產地
    function harvestCorn(address input, uint count) returns(string, address, uint) {
        identify[input].count = identify[input].count + count;
        bool flag = false;
        for (uint i = 0; i < Head.length; i++) {
            if (input == Head[i]) {
                flag = true;
                break;
            }
        }
        if (!flag) {
            Head.push(input);
        }

        return ("add corn success!", input, count);
    }

    //玉米流通啦，賣玉米啦
    //地址本身不能進行玉米流通
    function transpartCorn(address from1, address to, uint num) returns(string, bool) {
        if (from1 == to) {
            return ("you can't transfer corn to yourself", false);
        } else if (num == 0) {
            return ("you can't transfer zero corn to others", false);
        }
        if (identify[from1].count >= num) {
            identify[from1].count = identify[from1].count - num;
            identify[to].count = identify[to].count + num;

            //確定玉米流通的流向關系
            identify[from1].child.push(to);
            identify[to].father = from1;

            return ("add the corn success!", true);
        }
        return ("this from1 don't have enough corn!", false);
    }

    //查詢賬戶剩余玉米數
    function getCornCount(address query) returns(address, uint) {
        return (identify[query].father, identify[query].count);
    }


    //判斷當前地址所對應的對象是否屬於玉米某片地的角色
    function isInHead(address i) returns(bool) {
        for (uint j = 0; j < Head.length; j++) {
            if (Head[j] == i)
                return true;
        }
        return false;
    }

    address[] addrpath = new address[](1);
    //消費者查詢：我的玉米從哪里來
    function leafQuery(address consumer) returns(address[]) {
        addrpath.length = 0;
        addrpath[addrpath.length++] = consumer;
        while (!isInHead(addrpath[addrpath.length - 1])) {
            consumer = identify[addrpath[addrpath.length - 1]].father;
            addrpath[addrpath.length++] = consumer;
        }
        return addrpath;
    }

    //經銷商查詢：我的玉米從哪里來
    function nodeQueryCeil(address corn) returns(address[]) {
        return leafQuery(corn);
    }


    //經銷商查詢：玉米去哪了
    address[] queue = new address[](1);
    address[] ans = new address[](1);

    function nodeQueryFloor(address corn) returns(address[], address[]) {
        //內存化變量初始化
        uint index1;
        uint index2;
        address temp;
        //對經銷商節點開始進行層次遍歷，查找出所有的葉子節點
        index1 = 0;
        index2 = 1;
        addrpath.length = 0;
        queue.length = 0;
        queue[queue.length++] = corn;
        while (index1 != index2) {
            if (identify[queue[index1]].child.length == 0) {
                addrpath[addrpath.length++] = queue[index1];
            }
            index2 = index2 + identify[queue[index1]].child.length;
            for (uint i = 0; i < identify[queue[index1]].child.length; i++) {
                queue[queue.length++] = identify[queue[index1]].child[i];
            }
            index1++;
        }

        ans.length = 0;
        for (uint j = 0; j < addrpath.length; j++) {
            ans.push(addrpath[j]);
            temp = addrpath[j];
            while (temp != corn && identify[temp].father != corn) {
                ans.push(identify[temp].father);
                temp = identify[temp].father;
            }
            ans.push(corn);
        }
        return (addrpath, ans);
    }
}

 參考了一位前輩的經驗，對於不同類型物品的溯源，需要做到從頻率及價值兩個維度進行划分；【網名：netkiller，有自制手札】

pragma solidity ^0.4.10;

//**
// * Author：         ZJLavender
// * Date:            August 20
// * Update:          fix zero address bug
// * Version:         0.9.02
// * Introduction：   玉米合約用於：消費者溯源玉米來源，源產地及經銷商追蹤玉米流向，同時提供玉米正常流轉記錄方法，對常見流轉場景進行覆蓋，更多需求可以基於其上完善
// * /
contract CornTransport {
    
    uint256 RETURN_SUCCESS = 0;
    
    uint256 RETURN_DATAOVERFLOW = 10001;
    uint256 RETURN_FROMTOADDRESSSAME = 10002;
    uint256 RETURN_TRANSPORTCOUNTZERO = 10003;
    uint256 RETURN_CORNCOUNTNOTENOUGH = 10004;
    uint256 RETURN_ILLEGAL_ADDRESS = 10005;
    
    struct Consumer_Dealer_Origin {
        uint count;
        address addr_from;
        address[] addr_to;
    }
    
    address[] FieldsOfCornAddr;
    address[] addrpath;
    address[] queue;
    address[] ans;
    address NULL;
    
    mapping(address => Consumer_Dealer_Origin) identify;
    
    
    //functionName: harvestCorn
    //input:
    //         cornFieldAddr  address  Use address to replace cornField
    //         count  uint256  The number of corn this cornField havest
    //return:
    //         Return_Code  uint256  The Result Of invoke harvestCorn
    //         TheAddress address The input cornFieldAddr
    //         addrCornSum  The Sum of corn this Corn Field have
    function harvestCorn(address cornFieldAddr, uint256 count) returns(uint256 Return_Code, address TheAddress, uint256 addrCornSum) {
        if(cornFieldAddr == NULL){
           return (RETURN_ILLEGAL_ADDRESS, cornFieldAddr, identify[cornFieldAddr].count); 
        }else if( identify[cornFieldAddr].count + count >= identify[cornFieldAddr].count){
            identify[cornFieldAddr].count = identify[cornFieldAddr].count + count;    
        }else{
            return (RETURN_DATAOVERFLOW, cornFieldAddr, identify[cornFieldAddr].count);
        }
        
        bool flag = false;
        for (uint i = 0; i < FieldsOfCornAddr.length; i++) {
            if (cornFieldAddr == FieldsOfCornAddr[i]) {
                flag = true;
                break;
            }
        }
        if (!flag)
            FieldsOfCornAddr.push(cornFieldAddr);
        return (RETURN_SUCCESS, cornFieldAddr, identify[cornFieldAddr].count);

    }

    //functionName: transportCorn
    //input:
    //         fromAddr  address  the address who output corn
    //         toAddr  address  the address who input corn
    //          count   uint256 the transport number
    //return:
    //         Return_Code  uint256  The Result Of invoke transportCorn
    //         isSuccess bool The Result Of invoke transportCorn
    function transportCorn(address fromAddr, address toAddr, uint256 count) returns(uint256 Return_Code, bool isSuccess) {
        if(fromAddr == NULL || toAddr == NULL){
           return (RETURN_ILLEGAL_ADDRESS, false); 
        }else if (fromAddr == toAddr) {
            return (RETURN_FROMTOADDRESSSAME, false);
        } else if (count == 0) {
            return (RETURN_TRANSPORTCOUNTZERO, false);
        }
        
        if (identify[fromAddr].count >= count) {
            identify[fromAddr].count = identify[fromAddr].count - count;
            identify[toAddr].count = identify[toAddr].count + count;

            identify[fromAddr].addr_to.push(toAddr);
            identify[toAddr].addr_from = fromAddr;

            return (RETURN_SUCCESS, true);
        }
        return (RETURN_CORNCOUNTNOTENOUGH, false);
        
    }

    //functionName: getCornCount
    //input:
    //         query  address  the address query how much corn
    //return:
    //         cornCount  uint256  The number of corn count 
    function getCornCount(address query) returns(uint256 cornCount){
        return (identify[query].count);
    }
    
    
    //functionName: isInHead
    //input:
    //         isInHeadAddress  address  query address whether in Head 
    //return:
    //         bool  address whether in Head 
    function isInHead(address isInHeadAddress) returns(bool) {
        for (uint j = 0; j < FieldsOfCornAddr.length; j++) {
            if (FieldsOfCornAddr[j] == isInHeadAddress)
                return true;
        }
        return false;
    }

    //functionName: dealer_consumerQuery
    //input:
    //         consumer  address  input address query where corn from 
    //return:
    //         Answer   bool  invoke Answer 
    //          Return_Code uint256 Return_Code
    //          address[]   the path of where corn from
    function dealer_consumerQuery(address consumer) returns(bool Answer, uint256 Return_Code, address[]){
        addrpath.length = 0;
        addrpath[addrpath.length++] = consumer;
        while (!isInHead(addrpath[addrpath.length - 1])) {
            consumer = identify[addrpath[addrpath.length - 1]].addr_from;
            addrpath[addrpath.length++] = consumer;
            
            if(addrpath.length == 3 && addrpath[2] == addrpath[1]){
                return (false, RETURN_ILLEGAL_ADDRESS, addrpath);
            }
        }
        return (true, RETURN_SUCCESS, addrpath);
    }

    //functionName: origin_dealer_QueryCornTo
    //input:
    //         corn  address  input address query where corn to 
    //return:
    //         Answer   bool  invoke Answer 
    //          Return_Code uint256 Return_Code
    //          address[]   the node of where corn to
    //          address[]   the path of where corn to
    function origin_dealer_QueryCornTo(address corn) returns(bool, uint256, address[], address[]){
        uint index1;
        uint index2;
        address temp;

        index1 = 0;
        index2 = 1;
        addrpath.length = 0;
        queue.length = 0;
        queue[queue.length++] = corn;
        if(identify[corn].addr_to.length == 0){
            return(false, RETURN_ILLEGAL_ADDRESS, ans, ans);
        }
        
        while (index1 != index2) {
            if (identify[queue[index1]].addr_to.length == 0) {
                addrpath[addrpath.length++] = queue[index1];
            }
            index2 = index2 + identify[queue[index1]].addr_to.length;
            for (uint i = 0; i < identify[queue[index1]].addr_to.length; i++) {
                queue[queue.length++] = identify[queue[index1]].addr_to[i];
            }
            index1++;
        }

        ans.length = 0;
        for (uint j = 0; j < addrpath.length; j++) {
            ans.push(addrpath[j]);
            temp = addrpath[j];
            while (temp != corn && identify[temp].addr_from != corn) {
                ans.push(identify[temp].addr_from);
                temp = identify[temp].addr_from;
            }
            ans.push(corn);
        }
        
        return (true, RETURN_SUCCESS, addrpath, ans);
    }
    
}