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);
    }
    
}