What is Eurno?

Eurno is a directly democratic project which will use profits generated to complete charitable ventures which have been voted upon by the Eurno token holding community. Unlike traditional charities the Eurno project will use blockchain technology to ensure total transparency.

Transparently Charitable

Our charitable ventures are made entirely transparent through blockchain technology.

Directly Democratic

Our custom coded dApp will provide direct democracy to our community of token holders.

Enumivo logo

Released on the Enumivo Blockchain

The Eurno token (ENO) is one which started life as an ERC20 token on the popular dApp platform, Ethereum. It is now being prepared for distribution on the Enumivo main network blockchain, more info will be released shortly.

How are we Funded?

We will be funding the Eurno project through multiple cryptocurrency block producers, masternodes and partnerships. The Eurno project will also accept donations for both charitable ventures and development. Initially the Eurno token will be backed by 100k ENU tokens which will be donated to the project from the personal funds of our development team.

Enumivo

We will be operating a block producer on the Enumivo blockchain and donating 50% of the profits to the Eurno project

Draft Coin

Our Draft coin masternode will be donating at least 50% of its profitable income to the Eurno project.

Twist

We will be donating at least 50% of the profits earned from our Twist network masternode to the Eurno project.

Something Decent

Something Decent will donate 15% of the bounty donations they receive to the Eurno project.

Our Team

While there are a number of people who have confirmed that they will be joining the Eurno team, at present the following two people are the leading volunteers who have been dedicating all of their free time to ensuring that the project starts life successfully.The Eurno founder and CEO, Paul Singh, has made his personal linked in known below, as has Nadim.

Paul Singh (BSc)

Lead Developer/Founder/Chief Executive Officer (CEO)

Paul is the founder and the leading developer of the Eurno project, with over 10 years of experience in web development. He is also the founder of Something Decent and has been a core team member of the Enumivo project since shortly after its inception.

Nadim Meghji (BA)

Chief Technical and Financial Consultant (CTFC)

Nadim has over 14 years of experience within the financial industry which ended with him in the global corporate team of one of the world’s leading banks, and has been involved with the crypto industry since 2012. He is also a member of the Enumivo core team.

Eurno Token Details

The following table contains the overall breakdown of the Eurno token’s supply and distribution. Please note that the voteable dev fund” is listed as “to be decided” as it is to be funded via the methods listed above, thus a value cannot be placed on it. Also note that voteable balances are not to be active until we have moved to the Enumivo blockchain.

Eurno token details (ENO)
Non-voteable dev fund 5 million
Voteable dev fund Tokens to be bought using income streams mentioned above
UBI donation 1 million
Charitable venture fund 11.5 million
First distribution (airdrop) 23 million
Second distribution (voted) 9.5 million
Total supply of Eurno tokens 50 million

Ethereum Contract Details

Our contract can be found by searching for EurnoToken.eth or by going to the following address on Etherscan: 0xcdc4423531df5f3f87d1ff54047c769fe488c49f

Link: https://etherscan.io/address/0xcdc4423531df5f3f87d1ff54047c769fe488c49f

pragma solidity 0.4.24;

/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}

/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {

/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}

/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}

/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a); return a - b; } /** * @dev Adds two numbers, throws on overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a);
return c;
}
}

/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;

event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);

/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
owner = msg.sender;
}

/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(msg.sender == owner);
_;
}

/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}

/**
* @dev Allows the current owner to relinquish control of the contract.
*/
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
}

/**
* @title ForeignToken
* @dev Enables smart contract to hold and send other ERC20 tokens.
*/
contract ForeignToken {
function balanceOf(address _owner) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}

contract Eurno is ERC20Basic, Ownable, ForeignToken {
using SafeMath for uint256;

string public constant name = "Eurno";
string public constant symbol = "ENO";
uint public constant decimals = 8;
uint256 public totalSupply = 28e14;
uint256 internal functAttempts;

event Transfer(address indexed _from, address indexed _to, uint256 _value); // Define the transfer event
event Burn(address indexed burner, uint256 value);

mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) internal allowed;

/**
* @dev modifier to limit the number of times a function can be called to once.
*/
modifier onlyOnce(){
require(functAttempts <= 0); _; } /** * @dev Constructor function to start the Eurno token chain. * Transfer's the owner's wallet with the development fund of 5 million tokens. */ constructor() public { balances[msg.sender] = balances[msg.sender].add(totalSupply); // Update balances on the Ledger. emit Transfer(this, owner, totalSupply); // Transfer owner 5 mil dev fund. } /** * @dev total number of tokens in existence */ function totalSupply() public view returns (uint256) { return totalSupply; } /** * @dev transfer token for a specified address. * * Using onlyPayloadSize to prevent short address attack * @param _to The address to transfer to. * @param _value The amount to be transferred. */ function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } /** * @dev Allows the owner of the contract to distribute to other contracts. * Used, for example, to distribute the airdrop balance to the airdrop contract. * * @param _to is the address of the contract. * @param _value is the amount of ENO to send to it. */ function distAirdrop(address _to, uint256 _value) onlyOwner onlyOnce public returns (bool) { require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); functAttempts = 1; return true; } /** * @dev Gets the balance of the specified address. * @param _owner The address to query the the balance of. * @return An uint256 representing the amount owned by the passed address. */ function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } /** * @dev Function to withdraw foreign tokens stored in this contract. * * @param _tokenContract is the smart contract address of the token to be withdrawn. */ function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) { ForeignToken token = ForeignToken(_tokenContract); uint256 amount = token.balanceOf(address(this)); return token.transfer(owner, amount); } /** * @dev Fallback function to allow the contract to accept Eth donations. */ function() public payable { } /** * @dev Function to allow contract owner to withdraw Ethereum deposited to the Eurno contract. */ function withdraw() onlyOwner public { uint256 etherBalance = address(this).balance; owner.transfer(etherBalance); } /** * @dev Burns a specific amount of tokens. Can only be called by contract owner. * * @param _value The amount of token to be burned. */ function burn(uint256 _value) onlyOwner public { _burn(msg.sender, _value); } /** * @dev actual function to burn tokens. * * @param _who is the address of the person burning tokens. * @param _value is the number of tokens burned. */ function _burn(address _who, uint256 _value) internal { require(_value <= balances[_who]); // no need to require value <= totalSupply, since that would imply the // sender's balance is greater than the totalSupply, which *should* be an assertion failure balances[_who] = balances[_who].sub(_value); totalSupply = totalSupply.sub(_value); emit Burn(_who, _value); emit Transfer(_who, address(0), _value); } }

Enumivo Contract Details

Our Enumivo main network contract can be found by searching for token.eurno on the Enumivo block explorer or by clicking the following link: https://wallet.enumivo.com/accounts/token.eurno

The transaction which created the ENO token on the Enumivo network can be verified on the following link: https://wallet.enumivo.com/transactions/d01be77b57af92895cc89771446b2b78a9cbebf35e49c0c3e5a85a7a2f1a4fb2

Roadmap

The following roadmap is a rough indication of when the Eurno development team expects to meet certain milestones regarding the project's progress. While we will always do our utmost to ensure we beat our scheduled targets there is the possibility that the timeframes displayed below could be amended. We will ensure the roadmap below is updated on a regular basis.

Q4 2017

  • Started development

Q1 2018

  • Develop self claiming dApp
  • Develop the Eurno.org website
  • Develop the ENO ERC20 smart contract

Q2 2018

  • Alpha test the ENO ERC20 smart contract
  • Open Eurno.org website
  • Release Enumivo block producer details
  • Roll out Enumivo main net node
  • Release Eurno whitepaper
  • Closed beta test Eurno self claim dApp
  • Apply to exchanges/crypto trackers

Q3 2018

  • Begin bounty campaign
  • Release self claim airdrop dApp (paused, read ann here)
  • Develop Eurno smart contract on the Enumivo blockchain
  • Develop Eurno voting dApp

Q4 2018

  • Closed alpha test new smart contract on Enumivo
  • Closed beta test new smart contract on Enumivo
  • Plan Eurno token-swap

Q1 2019

  • Release Eurno smart contract on the Enumivo blockchain
  • Begin Eurno token-swap

Q2 2019

  • Closed alpha test Eurno voting dApp
  • Closed beta test Eurno voting dApp
  • Transfer 1m ENO tokens to the UBI dApp by Enumivo

Q3 2019

  • Public beta of Eurno voting dApp

Q4 2019

  • Release Eurno voting dApp
  • Initiate the first Eurno vote
  • Begin second ENO distribution

Contact Us

If you would like to contact us for any reason at all please feel free to use the form on the right hand side. We will do our best to get back to you within 48 hours but sometimes messages get lost in the spam box. If you need someone quickly please visit our social media channels below.

Contact us