Solidity合约:玉米生产溯源

实现思路：

首先用地址与每个结构进行映射，将关键信息储存在结构体中；或者将关键信息在外部通过json储存，内部储存对应的hash值；

使用issue函数表示：玉米地中收获足够数量的玉米并进行记录；

使用transfer函数表示：玉米在源产地与经销商手中流转，最终流转至消费者手中；

使用getCornCount函数：查询当前该角色所拥有的玉米数量；

使用IsInHead函数：判断当前该角色是否为玉米源产地；

使用LeafQuery函数：消费者查询玉米的来路，进行溯源操作；

使用NodeQueryFloor函数：经销商查询玉米的去路，进行商品去路调研获取数据，以便后期进行分析；

话不多说，先上代码：

 pragma solidity ^0.4.;

 //注意一些关键原则
 //自己不能给自己转玉米：确保不形成自环，且无现实意义；
 //每个地址代表一个角色；

 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==){
             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=;j < Head.length;j++){
             if(Head[j]==i)
                 return true;
         }
         return false;
     }

     address []addrpath = new address[]();
     //消费者查询：我的玉米从哪里来
     function LeafQuery(address consumer) returns (address[]){
         addrpath.length = ;
         addrpath[addrpath.length++]=consumer;
         while(!IsInHead(addrpath[addrpath.length-])){
             consumer = identify[addrpath[addrpath.length-]].father;
             addrpath[addrpath.length++]=consumer;
         }
         return addrpath;
     }

     //经销商查询：我的玉米从哪里来
     function NodeQueryCeil(address corn) returns (address[]) {
         return LeafQuery(corn);
     }

     //经销商查询：玉米去哪了
     address []queue = new address[]();
     uint index1;
     uint index2;
     function NodeQueryFloor(address corn) returns (address[]){
         //对经销商节点开始进行层次遍历，查找出所有的叶子节点
         index1=;
         index2=;
         addrpath.length = ;
         queue.length=;
         queue[queue.length++]=corn;
         while(index1!=index2){
             if(identify[queue[index1]].child.length==){
                 addrpath[addrpath.length++]=queue[index1];
             }
             index2 = index2+identify[queue[index1]].child.length;
             for(uint i=;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.;

 //使用继承的方式书写合约 使得整体逻辑变清晰
 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 = ; 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 == ) {
             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 = ; j < Head.length; j++) {
             if (Head[j] == i)
                 return true;
         }
         return false;
     }

     address[] addrpath = new address[]();
     //消费者查询：我的玉米从哪里来
     function leafQuery(address consumer) returns(address[]) {
         addrpath.length = ;
         addrpath[addrpath.length++] = consumer;
         while (!isInHead(addrpath[addrpath.length - ])) {
             consumer = identify[addrpath[addrpath.length - ]].father;
             addrpath[addrpath.length++] = consumer;
         }
         return addrpath;
     }

     //经销商查询：我的玉米从哪里来
     function nodeQueryCeil(address corn) returns(address[]) {
         return leafQuery(corn);
     }

     //经销商查询：玉米去哪了
     address[] queue = new address[]();
     address[] ans = new address[]();

     function nodeQueryFloor(address corn) returns(address[], address[]) {
         //内存化变量初始化
         uint index1;
         uint index2;
         address temp;
         //对经销商节点开始进行层次遍历，查找出所有的叶子节点
         index1 = ;
         index2 = ;
         addrpath.length = ;
         queue.length = ;
         queue[queue.length++] = corn;
         while (index1 != index2) {
             if (identify[queue[index1]].child.length == ) {
                 addrpath[addrpath.length++] = queue[index1];
             }
             index2 = index2 + identify[queue[index1]].child.length;
             for (uint i = ; i < identify[queue[index1]].child.length; i++) {
                 queue[queue.length++] = identify[queue[index1]].child[i];
             }
             index1++;
         }

         ans.length = ;
         for (uint j = ; 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.;

 //**
 // * Author：         ZJLavender
 // * Date:            August 20
 // * Update:          fix zero address bug
 // * Version:         0.9.02
 // * Introduction：   玉米合约用于：消费者溯源玉米来源，源产地及经销商追踪玉米流向，同时提供玉米正常流转记录方法，对常见流转场景进行覆盖，更多需求可以基于其上完善
 // * /
 contract CornTransport {

     uint256 RETURN_SUCCESS = ;

     uint256 RETURN_DATAOVERFLOW = ;
     uint256 RETURN_FROMTOADDRESSSAME = ;
     uint256 RETURN_TRANSPORTCOUNTZERO = ;
     uint256 RETURN_CORNCOUNTNOTENOUGH = ;
     uint256 RETURN_ILLEGAL_ADDRESS = ;

     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 = ; 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 == ) {
             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 = ; 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 = ;
         addrpath[addrpath.length++] = consumer;
         while (!isInHead(addrpath[addrpath.length - ])) {
             consumer = identify[addrpath[addrpath.length - ]].addr_from;
             addrpath[addrpath.length++] = consumer;

             if(addrpath.length ==  && addrpath[] == addrpath[]){
                 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 = ;
         index2 = ;
         addrpath.length = ;
         queue.length = ;
         queue[queue.length++] = corn;
         if(identify[corn].addr_to.length == ){
             return(false, RETURN_ILLEGAL_ADDRESS, ans, ans);
         }

         while (index1 != index2) {
             if (identify[queue[index1]].addr_to.length == ) {
                 addrpath[addrpath.length++] = queue[index1];
             }
             index2 = index2 + identify[queue[index1]].addr_to.length;
             for (uint i = ; i < identify[queue[index1]].addr_to.length; i++) {
                 queue[queue.length++] = identify[queue[index1]].addr_to[i];
             }
             index1++;
         }

         ans.length = ;
         for (uint j = ; 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);
     }

 }

bug fix 9.02