release V1.0.0 (#2)

* init

* read fix structure

* fix dir

* make it compile for 0.6.10

* add badge of downloads

* fix readme

Co-authored-by: aoronchu <[email protected]>

Author: dalaocu

README.md

@@ -1 +1,38 @@
-# sol-lib
+[![GitHub All Releases](https://img.shields.io/github/downloads/WeBankBlockchain/SmartDev-Contract/total.svg)](https://github.com/WeBankBlockchain/SmartDev-Contract)
+
+
+# 组件介绍
+
+智能合约库模板，涵盖了从基础类型到上层业务的常见代码，用户可根据实际需要进行参考、复用。
+
+[](https://toolkit-doc.readthedocs.io/zh_CN/latest/_images/wescott.png)
+
+## 环境要求
+
+| 依赖软件 | 说明 |备注|
+| --- | --- | --- |
+| Solidity | >= 0.6.10 | 需使用0.6.10版本编译|
+| Git | 下载需要使用Git | |
+
+## 文档
+- [**中文**](https://toolkit-doc.readthedocs.io/zh_CN/latest/docs/WeBankBlockchain-SmartDev-Contract/index.html)
+- [**快速开始**](https://toolkit-doc.readthedocs.io/zh_CN/latest/docs/WeBankBlockchain-SmartDev-Contract/quick_start.html)
+## 贡献代码
+欢迎参与本项目的社区建设：
+- 如项目对您有帮助，欢迎点亮我们的小星星(点击项目左上方Star按钮)。
+- 欢迎提交代码(Pull requests)。
+- [提问和提交BUG](https://github.com/WeBankBlockchain/SmartDev-Contract/issues)。
+- 如果发现代码存在安全漏洞，请在[这里](https://security.webank.com)上报。
+
+
+![](https://media.githubusercontent.com/media/FISCO-BCOS/LargeFiles/master/images/QR_image.png)
+
+
+## License
+![license](http://img.shields.io/badge/license-Apache%20v2-blue.svg)
+
+开源协议为[Apache License 2.0](http://www.apache.org/licenses/). 详情参考[LICENSE](../LICENSE)。
+
+
+
+

contracts/base_type/LibAddress.sol

@@ -0,0 +1,133 @@
+/*
+ * Copyright 2014-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * */
+ 
+pragma solidity >=0.4.24 <0.6.11;
+
+library LibAddress{
+    
+    /*
+     *@dev 
+     *@param
+     *@return
+     */
+    function isContract(address account) internal view returns(bool) {
+        uint256 size;
+        assembly { size := extcodesize(account) }  
+        return size > 0;
+    }
+
+    function isEmptyAddress(address addr) internal pure returns(bool){
+        return addr == address(0);
+    }
+
+
+    function addressToBytes(address addr) internal pure returns (bytes memory){
+        bytes20 addrBytes = bytes20(uint160(addr));
+        bytes memory rtn = new bytes(20);
+        for(uint8 i=0;i<20;i++){
+            rtn[i] = addrBytes[i];
+        }
+        return rtn;
+    }
+ 
+    
+    function bytesToAddress(bytes memory addrBytes) internal pure returns (address){
+        require(addrBytes.length == 20);
+        //Convert binary to uint160
+        uint160 intVal = 0;
+
+        for(uint8 i=0;i<20;i++){
+            intVal <<= 8;
+            intVal += uint8(addrBytes[i]);
+        }
+        return address(intVal);
+    }
+
+
+    function addressToString(address addr) internal pure returns(string memory){
+        //Convert addr to bytes
+        bytes20 value = bytes20(uint160(addr));
+        bytes memory strBytes = new bytes(42);
+        //Encode hex prefix
+        strBytes[0] = '0';
+        strBytes[1] = 'x';
+        //Encode bytes usig hex encoding
+        for(uint i=0;i<20;i++){
+            uint8 byteValue = uint8(value[i]);
+            strBytes[2 + (i<<1)] = encode((byteValue >> 4) & 0x0f);
+            strBytes[3 + (i<<1)] = encode(byteValue & 0x0f);
+        }
+        return string(strBytes);
+    }
+
+    function stringToAddress(string memory data) internal returns(address){
+        bytes memory strBytes = bytes(data);
+        require(strBytes.length >= 39 && strBytes.length <= 42, "Not hex string");
+        //Skip prefix
+        uint start = 0;
+        uint bytesBegin = 0;
+        if(strBytes[1] == 'x' || strBytes[1] == 'X'){
+            start = 2;
+        }
+        //Special case: 0xabc. should be 0x0abc
+        uint160 addrValue = 0;
+        uint effectPayloadLen = strBytes.length - start;
+        if(effectPayloadLen == 39){
+            addrValue += decode(strBytes[start++]);
+            bytesBegin++;
+        }
+        //Main loop
+        for(uint i=bytesBegin;i < 20; i++){
+            addrValue <<= 8;
+            uint8 tmp1 = decode(strBytes[start]);
+            uint8 tmp2 = decode(strBytes[start+1]);
+            uint8 combined = (tmp1 << 4) + tmp2;
+            addrValue += combined;
+            start+=2;
+        }
+        
+        return address(addrValue);
+    }
+
+
+    //-----------HELPER METHOD--------------//
+
+    //num represents a number from 0-15 and returns ascii representing [0-9A-Fa-f]
+    function encode(uint8 num) private pure returns(byte){
+        //0-9 -> 0-9
+        if(num >= 0 && num <= 9){
+            return byte(num + 48);
+        }
+        //10-15 -> a-f
+        return byte(num + 87);
+    }
+        
+    //asc represents one of the char:[0-9A-Fa-f] and returns consperronding value from 0-15
+    function decode(byte asc) private pure returns(uint8){
+        uint8 val = uint8(asc);
+        //0-9
+        if(val >= 48 && val <= 57){
+            return val - 48;
+        }
+        //A-F
+        if(val >= 65 && val <= 70){
+            return val - 55;
+        }
+        //a-f
+        return val - 87;
+    }
+
+}

contracts/base_type/LibArrayForUint256Utils.sol

@@ -0,0 +1,198 @@
+/*
+ * Copyright 2014-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * */
+ 
+pragma solidity >=0.4.24 <0.6.11;
+
+import "./LibSafeMathForUint256Utils.sol";
+
+library LibArrayForUint256Utils {
+
+	/**
+	 * @dev Searches a sortd uint256 array and returns the first element index that 
+	 * match the key value, Time complexity O(log n)
+	 *
+	 * @param array is expected to be sorted in ascending order
+	 * @param key is element 
+	 *
+	 * @return if matches key in the array return true,else return false 
+	 * @return the first element index that match the key value,if not exist,return 0
+	 */
+	function binarySearch(uint256[] storage array, uint256 key) internal view returns (bool, uint) {
+        if(array.length == 0){
+        	return (false, 0);
+        }
+
+        uint256 low = 0;
+        uint256 high = array.length-1;
+
+        while(low <= high){
+        	uint256 mid = LibSafeMathForUint256Utils.average(low, high);
+        	if(array[mid] == key){
+        		return (true, mid);
+        	}else if (array[mid] > key) {
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+
+        return (false, 0);
+    }
+
+    function firstIndexOf(uint256[] storage array, uint256 key) internal view returns (bool, uint256) {
+
+    	if(array.length == 0){
+    		return (false, 0);
+    	}
+
+    	for(uint256 i = 0; i < array.length; i++){
+    		if(array[i] == key){
+    			return (true, i);
+    		}
+    	}
+    	return (false, 0);
+    }
+
+    function reverse(uint256[] storage array) internal {
+        uint256 temp;
+        for (uint i = 0; i < array.length / 2; i++) {
+            temp = array[i];
+            array[i] = array[array.length - 1 - i];
+            array[array.length - 1 - i] = temp;
+        }
+    }
+
+    function equals(uint256[] storage a, uint256[] storage b) internal view returns (bool){
+    	if(a.length != b.length){
+    		return false;
+    	}
+    	for(uint256 i = 0; i < a.length; i++){
+    		if(a[i] != b[i]){
+    			return false;
+    		}
+    	}
+    	return true;
+    }
+
+    function removeByIndex(uint256[] storage array, uint index) internal{
+    	require(index < array.length, "ArrayForUint256: index out of bounds");
+
+        while (index < array.length - 1) {
+            array[index] = array[index + 1];
+            index++;
+        }
+        array.pop();
+    }
+    
+    function removeByValue(uint256[] storage array, uint256 value) internal{
+        uint index;
+        bool isIn;
+        (isIn, index) = firstIndexOf(array, value);
+        if(isIn){
+          removeByIndex(array, index);
+        }
+    }
+
+    function addValue(uint256[] storage array, uint256 value) internal{
+    	uint index;
+        bool isIn;
+        (isIn, index) = firstIndexOf(array, value);
+        if(!isIn){
+        	array.push(value);
+        }
+    }
+
+    function extend(uint256[] storage a, uint256[] storage b) internal {
+    	if(b.length != 0){
+    		for(uint i = 0; i < b.length; i++){
+    			a.push(b[i]);
+    		}
+    	}
+    }
+
+    function distinct(uint256[] storage array) internal returns (uint256 length) {
+        bool contains;
+        uint index;
+        for (uint i = 0; i < array.length; i++) {
+            bool contains = false;
+            uint256 index = 0;
+            for(uint j = i+1;j < array.length; j++){
+                if(array[j] == array[i]){
+                    contains =true;
+                    index = i;
+                    break;
+                }
+            }
+            if (contains) {
+                for (uint j = index; j < array.length - 1; j++){
+                    array[j] = array[j + 1];
+                }
+                array.pop();
+                i--;
+            }
+        }
+        length = array.length;
+    }
+
+    function qsort(uint256[] storage array) internal {
+        qsort(array, 0, array.length-1);
+    }
+
+    function qsort(uint256[] storage array, uint256 begin, uint256 end) private {
+        if(begin >= end || end == uint256(-1)) return;
+        uint256 pivot = array[end];
+
+        uint256 store = begin;
+        uint256 i = begin;
+        for(;i<end;i++){
+            if(array[i] < pivot){
+                uint256 tmp = array[i];
+                array[i] = array[store];
+                array[store] = tmp;
+                store++;
+            }
+        }
+
+        array[end] = array[store];
+        array[store] = pivot;
+
+        qsort(array, begin, store-1);
+        qsort(array, store+1, end);
+    }
+
+    function max(uint256[] storage array) internal view returns (uint256 maxValue, uint256 maxIndex) {
+        maxValue = array[0];
+        maxIndex = 0;
+        for(uint256 i = 0;i < array.length;i++){
+            if(array[i] > maxValue){
+                maxValue = array[i];
+                maxIndex = i;
+            }
+        }
+    }
+
+    function min(uint256[] storage array) internal view returns (uint256 minValue, uint256 minIndex) {
+        minValue = array[0];
+        minIndex = 0;
+        for(uint256 i = 0;i < array.length;i++){
+            if(array[i] < minValue){
+                minValue = array[i];
+                minIndex = i;
+            }
+        }
+    }
+
+}