Skip to content

Instantly share code, notes, and snippets.

@jpn0424

jpn0424/BytesToTypes.sol

Created May 31, 2019 06:03
Show Gist options
  • Save jpn0424/50a45283f99f999ec26c7e4818fb5210 to your computer and use it in GitHub Desktop.
Save jpn0424/50a45283f99f999ec26c7e4818fb5210 to your computer and use it in GitHub Desktop.
Download ZIP
Created using remix-ide: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://remix.ethereum.org/#version=soljson-v0.5.0+commit.1d4f565a.js&optimize=false&gist=
Raw
BytesToTypes.sol
pragma solidity ^0.5.0;
/**
* @title BytesToTypes
* @dev The BytesToTypes contract converts the memory byte arrays to the standard solidity types
* @author [email protected]
*/
contract BytesToTypes {
function bytesToAddress(uint _offst, bytes memory _input) internal pure returns (address _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToBool(uint _offst, bytes memory _input) internal pure returns (bool _output) {
uint8 x;
assembly {
x := mload(add(_input, _offst))
}
x==0 ? _output = false : _output = true;
}
function getStringSize(uint _offst, bytes memory _input) internal pure returns(uint size){
assembly{
size := mload(add(_input,_offst))
let chunk_count := add(div(size,32),1) // chunk_count = size/32 + 1
if gt(mod(size,32),0) {// if size%32 > 0
chunk_count := add(chunk_count,1)
}
size := mul(chunk_count,32)// first 32 bytes reseves for size in strings
}
}
function bytesToString(uint _offst, bytes memory _input, bytes memory _output) internal pure {
uint size = 32;
assembly {
let chunk_count
size := mload(add(_input,_offst))
chunk_count := add(div(size,32),1) // chunk_count = size/32 + 1
if gt(mod(size,32),0) {
chunk_count := add(chunk_count,1) // chunk_count++
}
for { let index:= 0 } lt(index , chunk_count){ index := add(index,1) } {
mstore(add(_output,mul(index,32)),mload(add(_input,_offst)))
_offst := sub(_offst,32) // _offst -= 32
}
}
}
function bytesToBytes32(uint _offst, bytes memory _input, bytes32 _output) internal pure {
assembly {
mstore(_output , add(_input, _offst))
mstore(add(_output,32) , add(add(_input, _offst),32))
}
}
function bytesToInt8(uint _offst, bytes memory _input) internal pure returns (int8 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt16(uint _offst, bytes memory _input) internal pure returns (int16 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt24(uint _offst, bytes memory _input) internal pure returns (int24 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt32(uint _offst, bytes memory _input) internal pure returns (int32 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt40(uint _offst, bytes memory _input) internal pure returns (int40 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt48(uint _offst, bytes memory _input) internal pure returns (int48 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt56(uint _offst, bytes memory _input) internal pure returns (int56 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt64(uint _offst, bytes memory _input) internal pure returns (int64 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt72(uint _offst, bytes memory _input) internal pure returns (int72 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt80(uint _offst, bytes memory _input) internal pure returns (int80 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt88(uint _offst, bytes memory _input) internal pure returns (int88 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt96(uint _offst, bytes memory _input) internal pure returns (int96 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt104(uint _offst, bytes memory _input) internal pure returns (int104 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt112(uint _offst, bytes memory _input) internal pure returns (int112 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt120(uint _offst, bytes memory _input) internal pure returns (int120 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt128(uint _offst, bytes memory _input) internal pure returns (int128 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt136(uint _offst, bytes memory _input) internal pure returns (int136 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt144(uint _offst, bytes memory _input) internal pure returns (int144 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt152(uint _offst, bytes memory _input) internal pure returns (int152 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt160(uint _offst, bytes memory _input) internal pure returns (int160 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt168(uint _offst, bytes memory _input) internal pure returns (int168 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt176(uint _offst, bytes memory _input) internal pure returns (int176 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt184(uint _offst, bytes memory _input) internal pure returns (int184 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt192(uint _offst, bytes memory _input) internal pure returns (int192 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt200(uint _offst, bytes memory _input) internal pure returns (int200 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt208(uint _offst, bytes memory _input) internal pure returns (int208 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt216(uint _offst, bytes memory _input) internal pure returns (int216 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt224(uint _offst, bytes memory _input) internal pure returns (int224 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt232(uint _offst, bytes memory _input) internal pure returns (int232 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt240(uint _offst, bytes memory _input) internal pure returns (int240 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt248(uint _offst, bytes memory _input) internal pure returns (int248 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToInt256(uint _offst, bytes memory _input) internal pure returns (int256 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint8(uint _offst, bytes memory _input) internal pure returns (uint8 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint16(uint _offst, bytes memory _input) internal pure returns (uint16 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint24(uint _offst, bytes memory _input) internal pure returns (uint24 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint32(uint _offst, bytes memory _input) internal pure returns (uint32 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint40(uint _offst, bytes memory _input) internal pure returns (uint40 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint48(uint _offst, bytes memory _input) internal pure returns (uint48 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint56(uint _offst, bytes memory _input) internal pure returns (uint56 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint64(uint _offst, bytes memory _input) internal pure returns (uint64 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint72(uint _offst, bytes memory _input) internal pure returns (uint72 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint80(uint _offst, bytes memory _input) internal pure returns (uint80 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint88(uint _offst, bytes memory _input) internal pure returns (uint88 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint96(uint _offst, bytes memory _input) internal pure returns (uint96 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint104(uint _offst, bytes memory _input) internal pure returns (uint104 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint112(uint _offst, bytes memory _input) internal pure returns (uint112 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint120(uint _offst, bytes memory _input) internal pure returns (uint120 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint128(uint _offst, bytes memory _input) internal pure returns (uint128 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint136(uint _offst, bytes memory _input) internal pure returns (uint136 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint144(uint _offst, bytes memory _input) internal pure returns (uint144 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint152(uint _offst, bytes memory _input) internal pure returns (uint152 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint160(uint _offst, bytes memory _input) internal pure returns (uint160 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint168(uint _offst, bytes memory _input) internal pure returns (uint168 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint176(uint _offst, bytes memory _input) internal pure returns (uint176 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint184(uint _offst, bytes memory _input) internal pure returns (uint184 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint192(uint _offst, bytes memory _input) internal pure returns (uint192 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint200(uint _offst, bytes memory _input) internal pure returns (uint200 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint208(uint _offst, bytes memory _input) internal pure returns (uint208 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint216(uint _offst, bytes memory _input) internal pure returns (uint216 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint224(uint _offst, bytes memory _input) internal pure returns (uint224 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint232(uint _offst, bytes memory _input) internal pure returns (uint232 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint240(uint _offst, bytes memory _input) internal pure returns (uint240 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint248(uint _offst, bytes memory _input) internal pure returns (uint248 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
function bytesToUint256(uint _offst, bytes memory _input) internal pure returns (uint256 _output) {
assembly {
_output := mload(add(_input, _offst))
}
}
}
Raw
fbethorder.sol
pragma solidity ^0.4.18;
contract Fbethorder {
event ActivityInfor(string location, string Abstract);
uint256 constant public ticketFee = 5 ether; // 票價 + 押金
uint256 constant public deposit = 2 ether; // 壓金
mapping (address => uint256) public ticketNumberMap;
mapping (uint256 => address) public id2AddrMap;
mapping (address => bool) public userJoinMap; // User Join ? true : False
uint256 public userAmount;
uint256 public ticketNumber;
address public FbWallet;
uint256 public activityEndTime;
bool public activityStatus; // activity start ? True : False
address public fborder;
uint256 public nowtime;
uint256 public maxAttendees;
uint256 public startTime;
function Fbethorder(uint256 _maxAttendees, uint256 _startTime, string _location, string _Abstract) public {
FbWallet = msg.sender;
maxAttendees = _maxAttendees;
userAmount = 0;
startTime = _startTime;
activityStatus = false;
fborder = msg.sender;
emit ActivityInfor( _location, _Abstract );
}
function GetNow() public {
nowtime = now;
}
function () payable external {
GetTicket(msg.sender);
}
function GetTicket (address participant) payable public {
require(msg.value >= ticketFee && ticketNumberMap[participant] == 0);
userAmount ++;
ticketNumber ++;
require(userAmount <= maxAttendees);
ticketNumberMap[participant] = ticketNumber;
id2AddrMap[userAmount] = participant;
}
/* 發起人設定結束時間，時間使用 UTC + 8 */
/* 活動開始時設定結束時間 */
function ActivityEndTime(uint256 endTime) public {
require(FbWallet == msg.sender);
activityEndTime = endTime;
activityStatus = true;
}
/* 確任使用者, 紀錄出席者 */
function UserAtt( ) public {
require(activityStatus == true && ticketNumberMap[msg.sender] != 0 && userJoinMap[msg.sender] == false);
userJoinMap[msg.sender] = true;
}
/* 課程結束，準時退回押金，延遲罰款 */
function Withdraw () public {
require(FbWallet == msg.sender);
for(uint i = 1; i <= userAmount; i++){
if(userJoinMap[id2AddrMap[i]] == false) continue;
/* 這邊時間要減去 UTC+8 */
if(now <= activityEndTime + 1 minutes){
id2AddrMap[i].transfer(deposit);
}else {
id2AddrMap[i].transfer(deposit + 1 ether);
}
}
FbWallet.transfer(this.balance);
}
}
Raw
fblife_pc.sol
pragma solidity ^0.5.0;
contract Ownable {
address private owner;
address private opServer;
constructor() public {
owner = msg.sender;
}
function isOwner() internal view returns(bool) {
return msg.sender == owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOpServer() internal view returns(bool) {
return msg.sender == opServer;
}
modifier onlyOpServer() {
require(isOpServer());
_;
}
function transferOwner(address newOwner) public onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
function transferOpServer(address newOpserver) external onlyOwner {
require(newOpserver != address(0));
opServer = newOpserver;
}
}
contract Checkpoint is Ownable {
address private checkpoint1;
address private checkpoint2;
address private checkpoint3;
function isCheckpoint1() internal view returns(bool) {
return msg.sender == checkpoint1;
}
function isCheckpoint2() internal view returns(bool) {
return msg.sender == checkpoint2;
}
function isCheckpoint3() internal view returns(bool) {
return msg.sender == checkpoint3;
}
modifier onlyCheckpoint1() {
require(isCheckpoint1());
_;
}
modifier onlyCheckpoint2() {
require(isCheckpoint2());
_;
}
modifier onlyCheckpoint3() {
require(isCheckpoint3());
_;
}
function transferCheckpoint(address newCheckpoint, uint8 sNumber) external onlyOwner {
require(newCheckpoint != address(0));
if(sNumber == 1) checkpoint1 = newCheckpoint;
if(sNumber == 2) checkpoint2 = newCheckpoint;
if(sNumber == 3) checkpoint3 = newCheckpoint;
}
}
contract TemplateEvent {
// 記錄商品平台傳來的資訊
event inseranceWeb(uint8 indexed eventIndex, uint256 poolCount, address customer, bytes dataFlow);
}
contract ExecutionStorage {
struct taskInfo {
address requestSource;
bytes arg;
bool validity;
}
struct checkList {
bool checkPoint1;
bool checkPoint2;
bool checkPoint3;
}
struct task {
taskInfo _taskInfo;
checkList _checkList;
}
mapping( uint256 => task ) taskPool;
uint256 private poolCount;
function add2Pool(bytes memory _arg) internal returns(uint256) {
taskPool[poolCount]._taskInfo.requestSource = msg.sender;
taskPool[poolCount]._taskInfo.arg = _arg;
taskPool[poolCount]._taskInfo.validity = false;
return poolCount++;
}
}
contract TemplateRule is ExecutionStorage, Checkpoint {
function isAllow(uint256 poolCount) internal view returns(bool) {
require((taskPool[poolCount]._checkList.checkPoint1 &&
taskPool[poolCount]._checkList.checkPoint2 &&
taskPool[poolCount]._checkList.checkPoint3) == true);
return true;
}
function transferCheckpoint1Status(uint256 poolCount, bool result) external onlyCheckpoint1 {
taskPool[poolCount]._checkList.checkPoint1 = result;
}
function transferCheckpoint2Status(uint256 poolCount, bool result) external onlyCheckpoint2 {
taskPool[poolCount]._checkList.checkPoint2 = result;
}
function transferCheckpoint3Status(uint256 poolCount, bool result) external onlyCheckpoint3 {
taskPool[poolCount]._checkList.checkPoint3 = result;
}
}
contract ParentContract is TemplateRule, TemplateEvent {
// frountend request to create a policy
function request(bytes calldata dataFlow) external {
emit inseranceWeb(1, add2Pool(dataFlow) - 1, msg.sender, dataFlow);
}
// create policy contract
function create(uint256 poolCount) external {
require(taskPool[poolCount]._taskInfo.requestSource == msg.sender && isAllow(poolCount));
new Contract("hellow");
}
}
// 合約模板模組
contract Contract {
string private tmpOut;
constructor (string memory tmp) public {
tmpOut = tmp;
}
}
Raw
fblife_scmp.sol
pragma solidity ^0.5.0;
// 提供權限管理
// 腳色：管理者、合約建立者
contract ManagePermission {
address private admin;
address private serverService;
constructor() public {
admin = msg.sender;
}
function isAdmin() internal view returns(bool) {
return msg.sender == admin;
}
modifier onlyAdmin() {
require(isAdmin());
_;
}
function isServer() internal view returns(bool) {
return msg.sender == serverService;
}
modifier onlyService() {
require(isServer());
_;
}
function setServerServiceAccount(address serverServiceAccount) external onlyAdmin {
serverService = serverServiceAccount;
}
}
// 基礎庫，數據儲存、數據結構、事件
// 後端服務會監控合約，當發生事件時，會將記錄拋上 receipt。
contract FbBase is ManagePermission {
struct policyContract {
uint256 eventId; // 事件流水號
uint256 FKtransEvent;
uint256 createTime;
address creator;
bytes32 transHash; // 交易號
address contractAddress; // 合約地址
uint256 templateIndex; // 使用樣本索引
bool tableEffect; // 有效性
}
struct transEvent {
uint256 eventId; // 事件流水號
uint256 eventTime;
uint256 eventAtt; // 事件屬性
address driver; // 事件驅動者
bool tableEffect; // 有效性
}
struct userSchema {
uint256 eventId;
mapping (uint256 => policyContract) policyContractRepo;
mapping (uint256 => transEvent) transEventByRepo;
}
mapping (address => userSchema) userInfo;
event PCMEvent(uint256 indexed eventIndex, string actionIndex, uint256 templateInfoIndex);
}
// Template Interface
contract ParentContractInterface {
function create(bytes calldata dataFlow) external;
}
// 父合約管理模組
contract ParentContractManagement is FbBase {
struct parentContract {
string author;
address contractAddress;
bool effectiveness;
}
// 樣板資訊
mapping (uint256 => parentContract) parentContractInfo;
ParentContractInterface parentContractInterface;
function getParentContractPointer(uint256 id) internal {
parentContractInterface = ParentContractInterface(parentContractInfo[id].contractAddress);
}
function setParentContractAddress(uint256 id, address location) external onlyAdmin() {
parentContractInfo[id].contractAddress = location;
parentContractInfo[id].effectiveness = true;
emit PCMEvent(1, "setAddress", id);
}
}
contract FbLifeInterface is ParentContractManagement {
// 建立樣板
function createPolicyContract(uint256 id, bytes calldata dataFlow) external {
getParentContractPointer(id);
parentContractInterface.create(dataFlow);
emit PCMEvent(1, "createPolicyContract", id);
}
}
Raw
Seriality.sol
pragma solidity ^0.5.0;
/**
* @title Seriality
* @dev The Seriality contract is the main interface for serializing data using the TypeToBytes, BytesToType and SizeOf
* @author [email protected]
*/
import "./BytesToTypes.sol";
import "./TypesToBytes.sol";
import "./SizeOf.sol";
contract Seriality is BytesToTypes, TypesToBytes, SizeOf {
constructor() public {
}
}
Raw
serialization.sol
pragma solidity ^0.5.0;
import "./Seriality.sol";
contract StringsReturn is Seriality {
function stringCaller() public pure returns( string memory out1,
string memory out2,
string memory out3,
string memory out4,
string memory out5)
{
bytes memory buffer = new bytes(320);
uint offset = stringCallee(buffer);
//deserializing
out1 = new string (getStringSize(offset, buffer));
bytesToString(offset, buffer, bytes(out1));
offset -= sizeOfString(out1);
out2 = new string (getStringSize(offset, buffer));
bytesToString(offset, buffer, bytes(out2));
offset -= sizeOfString(out2);
out3 = new string (getStringSize(offset, buffer));
bytesToString(offset, buffer, bytes(out3));
offset -= sizeOfString(out3);
out4 = new string (getStringSize(offset, buffer));
bytesToString(offset, buffer, bytes(out4));
offset -= sizeOfString(out4);
out5 = new string (getStringSize(offset, buffer));
bytesToString(offset, buffer, bytes(out5));
}
function stringCallee(bytes memory buffer) public pure returns (uint buffer_size) {
string memory out1 = new string(32);
string memory out2 = new string(32);
string memory out3 = new string(32);
string memory out4 = new string(32);
string memory out5 = new string(32);
out1 = "Come on baby lets dance!";
out2 = "May I buy you a drink?";
out3 = "I am an itinerant programmer";
out4 = "Inam javab lashi!";
out5 = "Bia inja dahan service";
// Serializing
buffer_size = sizeOfString(out5) +
sizeOfString(out4) +
sizeOfString(out3) +
sizeOfString(out2) +
sizeOfString(out1);
uint offset = buffer_size;
stringToBytes(offset, bytes(out1), buffer);
offset -= sizeOfString(out1);
stringToBytes(offset, bytes(out2), buffer);
offset -= sizeOfString(out2);
stringToBytes(offset, bytes(out3), buffer);
offset -= sizeOfString(out3);
stringToBytes(offset, bytes(out4), buffer);
offset -= sizeOfString(out4);
stringToBytes(offset, bytes(out5), buffer);
return buffer_size;
}
}
Raw
SizeOf.sol
pragma solidity ^0.5.0;
/**
* @title SizeOf
* @dev The SizeOf return the size of the solidity types in byte
* @author [email protected]
*/
contract SizeOf {
function sizeOfString(string memory _in) internal pure returns(uint _size){
_size = bytes(_in).length / 32;
if(bytes(_in).length % 32 != 0)
_size++;
_size++; // first 32 bytes is reserved for the size of the string
_size *= 32;
}
function sizeOfInt(uint16 _postfix) internal pure returns(uint size){
assembly{
switch _postfix
case 8 { size := 1 }
case 16 { size := 2 }
case 24 { size := 3 }
case 32 { size := 4 }
case 40 { size := 5 }
case 48 { size := 6 }
case 56 { size := 7 }
case 64 { size := 8 }
case 72 { size := 9 }
case 80 { size := 10 }
case 88 { size := 11 }
case 96 { size := 12 }
case 104 { size := 13 }
case 112 { size := 14 }
case 120 { size := 15 }
case 128 { size := 16 }
case 136 { size := 17 }
case 144 { size := 18 }
case 152 { size := 19 }
case 160 { size := 20 }
case 168 { size := 21 }
case 176 { size := 22 }
case 184 { size := 23 }
case 192 { size := 24 }
case 200 { size := 25 }
case 208 { size := 26 }
case 216 { size := 27 }
case 224 { size := 28 }
case 232 { size := 29 }
case 240 { size := 30 }
case 248 { size := 31 }
case 256 { size := 32 }
default { size := 32 }
}
}
function sizeOfUint(uint16 _postfix) internal pure returns(uint size){
return sizeOfInt(_postfix);
}
function sizeOfAddress() internal pure returns(uint8){
return 20;
}
function sizeOfBool() internal pure returns(uint8){
return 1;
}
}
Raw
TypesToBytes.sol
pragma solidity ^0.5.0;
/**
* @title TypesToBytes
* @dev The TypesToBytes contract converts the standard solidity types to the byte array
* @author [email protected]
*/
contract TypesToBytes {
constructor() internal {
}
function addressToBytes(uint _offst, address _input, bytes memory _output) internal pure {
assembly {
mstore(add(_output, _offst), _input)
}
}
function bytes32ToBytes(uint _offst, bytes32 _input, bytes memory _output) internal pure {
assembly {
mstore(add(_output, _offst), _input)
mstore(add(add(_output, _offst),32), add(_input,32))
}
}
function boolToBytes(uint _offst, bool _input, bytes memory _output) internal pure {
uint8 x = _input == false ? 0 : 1;
assembly {
mstore(add(_output, _offst), x)
}
}
function stringToBytes(uint _offst, bytes memory _input, bytes memory _output) internal pure {
uint256 stack_size = _input.length / 32;
if(_input.length % 32 > 0) stack_size++;
assembly {
stack_size := add(stack_size,1)//adding because of 32 first bytes memory as the length
for { let index := 0 } lt(index,stack_size){ index := add(index ,1) } {
mstore(add(_output, _offst), mload(add(_input,mul(index,32))))
_offst := sub(_offst , 32)
}
}
}
function intToBytes(uint _offst, int _input, bytes memory _output) internal pure {
assembly {
mstore(add(_output, _offst), _input)
}
}
function uintToBytes(uint _offst, uint _input, bytes memory _output) internal pure {
assembly {
mstore(add(_output, _offst), _input)
}
}
}
Raw
Untitled.sol
/**
* Source Code first verified at https://etherscan.io on Tuesday, May 21, 2019
(UTC) */
pragma solidity ^0.5.0;
// Bitfinex LEO Token 2019
// Based on Giveth's MiniMe Token framework
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// Modified 2019, Will Harborne
/*
Copyright 2016, Jordi Baylina
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/// @title MiniMeToken Contract
/// @author Jordi Baylina
/// @dev This token contract's goal is to make it easy for anyone to clone this
/// token using the token distribution at a given block, this will allow DAO's
/// and DApps to upgrade their features in a decentralized manner without
/// affecting the original token
/// @dev It is ERC20 compliant, but still needs to under go further testing.
contract Controlled {
event ControlTransferred(address indexed previousControler, address indexed newController);
/// @notice The address of the controller is the only address that can call
/// a function with this modifier
modifier onlyController { require(msg.sender == controller); _; }
address public controller;
constructor() public { controller = msg.sender;}
/// @notice Changes the controller of the contract
/// @param _newController The new controller of the contract
function changeController(address _newController) public onlyController {
emit ControlTransferred(controller, _newController);
controller = _newController;
}
}
contract TokenController {
/// @notice Called when `_owner` sends ether to the MiniMe Token contract
/// @param _owner The address that sent the ether to create tokens
/// @return True if the ether is accepted, false if it throws
function proxyPayment(address _owner) public payable returns(bool);
/// @notice Notifies the controller about a token transfer allowing the
/// controller to react if desired
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @return False if the controller does not authorize the transfer
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
/// @notice Notifies the controller about an approval allowing the
/// controller to react if desired
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @return False if the controller does not authorize the approval
function onApprove(address _owner, address _spender, uint _amount) public
returns(bool);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes memory _data) public;
}
/// @dev The actual token contract, the default controller is the msg.sender
/// that deploys the contract, so usually this token will be deployed by a
/// token controller contract, which Giveth will call a "Campaign"
/// @dev The actual token contract, the default controller is the msg.sender
/// that deploys the contract, so usually this token will be deployed by a
/// token controller contract, which Giveth will call a "Campaign"
contract MiniMeToken is Controlled {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
string public version = '3.0.0'; //An arbitrary versioning scheme
/// @dev `Checkpoint` is the structure that attaches a block number to a
/// given value, the block number attached is the one that last changed the
/// value
struct Checkpoint {
// `fromBlock` is the block number that the value was generated from
uint256 fromBlock;
// `value` is the amount of tokens at a specific block number
uint256 value;
}
// `parentToken` is the Token address that was cloned to produce this token;
// it will be 0x0 for a token that was not cloned
MiniMeToken public parentToken;
// `parentSnapShotBlock` is the block number from the Parent Token that was
// used to determine the initial distribution of the Clone Token
uint public parentSnapShotBlock;
// `creationBlock` is the block number that the Clone Token was created
uint public creationBlock;
// `balances` is the map that tracks the balance of each address, in this
// contract when the balance changes the block number that the change
// occurred is also included in the map
mapping (address => Checkpoint[]) balances;
// `allowed` tracks any extra transfer rights as in all ERC20 tokens
mapping (address => mapping (address => uint256)) allowed;
// Tracks the history of the `totalSupply` of the token
Checkpoint[] totalSupplyHistory;
// Flag that determines if the token is transferable or not.
bool public transfersEnabled;
// The factory used to create new clone tokens
MiniMeTokenFactory public tokenFactory;
////////////////
// Constructor
////////////////
/// @notice Constructor to create a MiniMeToken
/// @param _tokenFactory The address of the MiniMeTokenFactory contract that
/// will create the Clone token contracts, the token factory needs to be
/// deployed first
/// @param _parentToken Address of the parent token, set to 0x0 if it is a
/// new token
/// @param _parentSnapShotBlock Block of the parent token that will
/// determine the initial distribution of the clone token, set to 0 if it
/// is a new token
/// @param _tokenName Name of the new token
/// @param _decimalUnits Number of decimals of the new token
/// @param _tokenSymbol Token Symbol for the new token
/// @param _transfersEnabled If true, tokens will be able to be transferred
constructor(
address _tokenFactory,
address payable _parentToken,
uint _parentSnapShotBlock,
string memory _tokenName,
uint8 _decimalUnits,
string memory _tokenSymbol,
bool _transfersEnabled
) public {
tokenFactory = MiniMeTokenFactory(_tokenFactory);
name = _tokenName; // Set the name
decimals = _decimalUnits; // Set the decimals
symbol = _tokenSymbol; // Set the symbol
parentToken = MiniMeToken(_parentToken);
parentSnapShotBlock = _parentSnapShotBlock;
transfersEnabled = _transfersEnabled;
creationBlock = block.number;
}
///////////////////
// ERC20 Methods
///////////////////
uint constant MAX_UINT = 2**256 - 1;
/// @notice Send `_amount` tokens to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
doTransfer(msg.sender, _to, _amount);
return true;
}
/// @notice Send `_amount` tokens to `_to` from `_from` on the condition it
/// is approved by `_from`
/// @param _from The address holding the tokens being transferred
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
/// @return True if the transfer was successful
function transferFrom(address _from, address _to, uint256 _amount
) public returns (bool success) {
// The controller of this contract can move tokens around at will,
// this is important to recognize! Confirm that you trust the
// controller of this contract, which in most situations should be
// another open source smart contract or 0x0
if (msg.sender != controller) {
require(transfersEnabled);
// The standard ERC 20 transferFrom functionality
if (allowed[_from][msg.sender] < MAX_UINT) {
require(allowed[_from][msg.sender] >= _amount);
allowed[_from][msg.sender] -= _amount;
}
}
doTransfer(_from, _to, _amount);
return true;
}
/// @dev This is the actual transfer function in the token contract, it can
/// only be called by other functions in this contract.
/// @param _from The address holding the tokens being transferred
/// @param _to The address of the recipient
/// @param _amount The amount of tokens to be transferred
/// @return True if the transfer was successful
function doTransfer(address _from, address _to, uint _amount
) internal {
if (_amount == 0) {
emit Transfer(_from, _to, _amount); // Follow the spec to louch the event when transfer 0
return;
}
require(parentSnapShotBlock < block.number);
// Do not allow transfer to 0x0 or the token contract itself
require((_to != address(0)) && (_to != address(this)));
// If the amount being transfered is more than the balance of the
// account the transfer throws
uint256 previousBalanceFrom = balanceOfAt(_from, block.number);
require(previousBalanceFrom >= _amount);
// Alerts the token controller of the transfer
if (isContract(controller)) {
require(TokenController(controller).onTransfer(_from, _to, _amount));
}
// First update the balance array with the new value for the address
// sending the tokens
updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
// Then update the balance array with the new value for the address
// receiving the tokens
uint256 previousBalanceTo = balanceOfAt(_to, block.number);
require(previousBalanceTo + _amount >= previousBalanceTo); // Check for overflow
updateValueAtNow(balances[_to], previousBalanceTo + _amount);
// An event to make the transfer easy to find on the blockchain
emit Transfer(_from, _to, _amount);
}
/// @param _owner The address that's balance is being requested
/// @return The balance of `_owner` at the current block
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
/// @notice `msg.sender` approves `_spender` to spend `_amount` tokens on
/// its behalf. This is a modified version of the ERC20 approve function
/// to be a little bit safer
/// @param _spender The address of the account able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the approval was successful
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender,0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
// Alerts the token controller of the approve function call
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
/// @dev This function makes it easy to read the `allowed[]` map
/// @param _owner The address of the account that owns the token
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens of _owner that _spender is allowed
/// to spend
function allowance(address _owner, address _spender
) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// @param _spender The address of the contract able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the function call was successful
function approveAndCall(address _spender, uint256 _amount, bytes memory _extraData
) public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(
msg.sender,
_amount,
address(this),
_extraData
);
return true;
}
/// @dev This function makes it easy to get the total number of tokens
/// @return The total number of tokens
function totalSupply() public view returns (uint) {
return totalSupplyAt(block.number);
}
////////////////
// Query balance and totalSupply in History
////////////////
/// @dev Queries the balance of `_owner` at a specific `_blockNumber`
/// @param _owner The address from which the balance will be retrieved
/// @param _blockNumber The block number when the balance is queried
/// @return The balance at `_blockNumber`
function balanceOfAt(address _owner, uint _blockNumber) public view
returns (uint) {
// These next few lines are used when the balance of the token is
// requested before a check point was ever created for this token, it
// requires that the `parentToken.balanceOfAt` be queried at the
// genesis block for that token as this contains initial balance of
// this token
if ((balances[_owner].length == 0)
|| (balances[_owner][0].fromBlock > _blockNumber)) {
if (address(parentToken) != address(0)) {
return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
} else {
// Has no parent
return 0;
}
// This will return the expected balance during normal situations
} else {
return getValueAt(balances[_owner], _blockNumber);
}
}
/// @notice Total amount of tokens at a specific `_blockNumber`.
/// @param _blockNumber The block number when the totalSupply is queried
/// @return The total amount of tokens at `_blockNumber`
function totalSupplyAt(uint _blockNumber) public view returns(uint) {
// These next few lines are used when the totalSupply of the token is
// requested before a check point was ever created for this token, it
// requires that the `parentToken.totalSupplyAt` be queried at the
// genesis block for this token as that contains totalSupply of this
// token at this block number.
if ((totalSupplyHistory.length == 0)
|| (totalSupplyHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != address(0)) {
return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
// This will return the expected totalSupply during normal situations
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
////////////////
// Clone Token Method
////////////////
/// @notice Creates a new clone token with the initial distribution being
/// this token at `_snapshotBlock`
/// @param _cloneTokenName Name of the clone token
/// @param _cloneDecimalUnits Number of decimals of the smallest unit
/// @param _cloneTokenSymbol Symbol of the clone token
/// @param _snapshotBlock Block when the distribution of the parent token is
/// copied to set the initial distribution of the new clone token;
/// if the block is zero than the actual block, the current block is used
/// @param _transfersEnabled True if transfers are allowed in the clone
/// @return The address of the new MiniMeToken Contract
function createCloneToken(
string memory _cloneTokenName,
uint8 _cloneDecimalUnits,
string memory _cloneTokenSymbol,
uint _snapshotBlock,
bool _transfersEnabled
) public returns(address) {
if (_snapshotBlock == 0) _snapshotBlock = block.number;
MiniMeToken cloneToken = tokenFactory.createCloneToken(
address(this),
_snapshotBlock,
_cloneTokenName,
_cloneDecimalUnits,
_cloneTokenSymbol,
_transfersEnabled
);
cloneToken.changeController(msg.sender);
// An event to make the token easy to find on the blockchain
emit NewCloneToken(address(cloneToken), _snapshotBlock);
return address(cloneToken);
}
////////////////
// Generate and destroy tokens
////////////////
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _owner The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _owner, uint _amount
) public onlyController returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply + _amount >= curTotalSupply); // Check for overflow
uint previousBalanceTo = balanceOf(_owner);
require(previousBalanceTo + _amount >= previousBalanceTo); // Check for overflow
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
emit Transfer(address(0), _owner, _amount);
return true;
}
/// @notice Burns `_amount` tokens from `_owner`
/// @param _owner The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _owner, uint _amount
) onlyController public returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply >= _amount);
uint previousBalanceFrom = balanceOf(_owner);
require(previousBalanceFrom >= _amount);
updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
emit Transfer(_owner, address(0), _amount);
return true;
}
////////////////
// Enable tokens transfers
////////////////
/// @notice Enables token holders to transfer their tokens freely if true
/// @param _transfersEnabled True if transfers are allowed in the clone
function enableTransfers(bool _transfersEnabled) public onlyController {
transfersEnabled = _transfersEnabled;
}
////////////////
// Internal helper functions to query and set a value in a snapshot array
////////////////
/// @dev `getValueAt` retrieves the number of tokens at a given block number
/// @param checkpoints The history of values being queried
/// @param _block The block number to retrieve the value at
/// @return The number of tokens being queried
function getValueAt(Checkpoint[] storage checkpoints, uint _block
) view internal returns (uint) {
if (checkpoints.length == 0) return 0;
// Shortcut for the actual value
if (_block >= checkpoints[checkpoints.length-1].fromBlock)
return checkpoints[checkpoints.length-1].value;
if (_block < checkpoints[0].fromBlock) return 0;
// Binary search of the value in the array
uint min = 0;
uint max = checkpoints.length-1;
uint mid = 0;
while (max > min) {
mid = (max + min + 1)/ 2;
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
} else {
max = mid-1;
}
}
return checkpoints[min].value;
}
/// @dev `updateValueAtNow` used to update the `balances` map and the
/// `totalSupplyHistory`
/// @param checkpoints The history of data being updated
/// @param _value The new number of tokens
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value
) internal {
if ((checkpoints.length == 0)
|| (checkpoints[checkpoints.length -1].fromBlock < block.number)) {
Checkpoint storage newCheckPoint = checkpoints[ checkpoints.length++ ];
newCheckPoint.fromBlock = uint256(block.number);
newCheckPoint.value = uint256(_value);
} else {
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1];
oldCheckPoint.value = uint256(_value);
}
}
/// @dev Internal function to determine if an address is a contract
/// @param _addr The address being queried
/// @return True if `_addr` is a contract
function isContract(address _addr) view internal returns(bool) {
uint size;
if (_addr == address(0)) return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
/// @dev Helper function to return a min betwen the two uints
function min(uint a, uint b) pure internal returns (uint) {
return a < b ? a : b;
}
/// @notice The fallback function: If the contract's controller has not been
/// set to 0, then the `proxyPayment` method is called which relays the
/// ether and creates tokens as described in the token controller contract
function () external payable {
require(isContract(controller));
require(TokenController(controller).proxyPayment.value(msg.value)(msg.sender));
}
////////////////
// Events
////////////////
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _amount
);
}
////////////////
// MiniMeTokenFactory
////////////////
/// @dev This contract is used to generate clone contracts from a contract.
/// In solidity this is the way to create a contract from a contract of the
/// same class
contract MiniMeTokenFactory {
/// @notice Update the DApp by creating a new token with new functionalities
/// the msg.sender becomes the controller of this clone token
/// @param _parentToken Address of the token being cloned
/// @param _snapshotBlock Block of the parent token that will
/// determine the initial distribution of the clone token
/// @param _tokenName Name of the new token
/// @param _decimalUnits Number of decimals of the new token
/// @param _tokenSymbol Token Symbol for the new token
/// @param _transfersEnabled If true, tokens will be able to be transferred
/// @return The address of the new token contract
function createCloneToken(
address payable _parentToken,
uint _snapshotBlock,
string memory _tokenName,
uint8 _decimalUnits,
string memory _tokenSymbol,
bool _transfersEnabled
) public returns (MiniMeToken) {
MiniMeToken newToken = new MiniMeToken(
address(this),
_parentToken,
_snapshotBlock,
_tokenName,
_decimalUnits,
_tokenSymbol,
_transfersEnabled
);
newToken.changeController(msg.sender);
return newToken;
}
}
contract LEO is MiniMeToken {
constructor(
address _tokenFactory,
address initialOwner
) public MiniMeToken(
_tokenFactory,
address(0), // no parent token
0, // no snapshot block number from parent
"Bitfinex LEO Token", // Token name
18, // Decimals
"LEO", // Symbol
true // Enable transfers
) {
generateTokens(initialOwner, 660000000000000000000000000);
}
}
contract LEOController is TokenController, Ownable {
LEO public tokenContract; // The new token for this Campaign
/// @param _tokenAddress Address of the token contract this contract controls
constructor(
address payable _tokenAddress
) public {
tokenContract = LEO(_tokenAddress); // The Deployed Token Contract
}
/////////////////
// TokenController interface
/////////////////
/// @notice Notifies the controller about a transfer.
/// Transfers can only happen to whitelisted addresses
/// @param _from The origin of the transfer
/// @param _to The destination of the transfer
/// @param _amount The amount of the transfer
/// @return False if the controller does not authorize the transfer
function onTransfer(address _from, address _to, uint _amount) public returns(bool) {
return true;
}
/// @notice Notifies the controller about an approval, for this Campaign all
/// approvals are allowed by default and no extra notifications are needed
/// @param _owner The address that calls `approve()`
/// @param _spender The spender in the `approve()` call
/// @param _amount The amount in the `approve()` call
/// @return False if the controller does not authorize the approval
function onApprove(address _owner, address _spender, uint _amount) public
returns(bool)
{
return true;
}
function proxyPayment(address _owner) public payable returns(bool allowed) {
allowed = false;
}
/// @notice `onlyOwner` can upgrade the controller contract
/// @param _newControllerAddress The address that will have the token control logic
function upgradeController(address _newControllerAddress) public onlyOwner {
tokenContract.changeController(_newControllerAddress);
emit UpgradedController(_newControllerAddress);
}
function burnTokens(uint _amount) public onlyOwner returns (bool) {
tokenContract.destroyTokens(owner, _amount);
}
function issueTokens(uint _amount) public onlyOwner returns (bool) {
tokenContract.generateTokens(owner, _amount);
}
//////////
// Safety Methods
//////////
/// @notice This method can be used by the owner to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
function claimLostTokens(address payable _token) public onlyOwner {
LEO token = LEO(_token);
uint balance = token.balanceOf(address(this));
token.transfer(owner, balance);
emit ClaimedTokens(_token, owner, balance);
}
////////////////
// Events
////////////////
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event UpgradedController (address newAddress);
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment