DAO.Casino Blockchain protocol for gambling Token Sale Starts on June 29th 01:00 PM GMT 01 Day 16 Hours 46 Minutes 33 Seconds Subscribe and be first to know about Token Sale Enter your email address Subscribe CREATED BY FOUNDERS OF Features Transparent Everything in the system from random number generation to rewards distribution is transparent, auditable and administered by cryptographically verifiable code. No one can change the rules secretly in their own favour. P2P marketplace Game developers deliver the games directly to the players, raise funds for the bankroll from the community and use automated reward mechanism to remunerate players, who invite other players. Authors IP stays with the authors. Game devs don’t need a casino, anyone can just be their own casino. Owned by everyone No participant has power over another. Whoever contributes value gets automatically rewarded by the system. It is designed to be fair, and doesn’t have to rely on a potentially corruptible trusted third party. Highest payout By design a decentralised system doesn’t encourage rent-seeking behaviour. So no one can take a cut for nothing which allows higher pay outs than in a traditional online casino. Random numbers that determine who wins any given games are provably unpredictable, which means no one can win just by knowing the outcome What is DAO.Casino? How it works Platform Operators (white label) Game Developers Referrals Contributors Investors & Bankrolls Random Generators *BET = DAO.Casino tokens Roadmap 2016 Market Research Technical feasibility Assessment Q2-1 2017 Platform Alpha Dice game beta Black Jack beta Protocol main contract WP release Q3 2017 Contribution campaign Q4 2017 Official release platform (testnet) Multiplayer RNG release Lottery beta Q1 2017 First game release on Edcon Platform prototype Q2-2 2017 Public audit RNG Signidice integration Q3 2017 Multiplayer RNG research Lottery Alpha Slot game Alpha IPFS integration 2018 VR platform Betting integration Prediction Integration DAO.Casino JS Partners Our Team Ilya Tarutov CEO Konstantin Lomashuk Protocol Architect Alexander Noxon CTO / Platform development Ksenya Bellman Business development Alexandra Fetisova Project Manager Sergey Pomorin Game developer Sergey Lonshakov DAO design and implementation Alexander Krupenkin Solidity Developer Eugene Radchenko Program Manager Alexander Davidov Solidity Developer Alex Kirillov CFO Akbar Murataliev Marketing Executive Stepanchenko Alexander Full Stack Developer Theo Goodman Community Manager (Germany) Advisers Bruce Elliott Adviser Eric Benz Adviser Do not miss Dao.Casino Token Sale Subscribe and be first to know about Token Sale
вторник, 27 июня 2017 г.
Получился какой-то криптовыпуск: майнинг, ethereum, блокчейн, litecoin, страхование, фермы. И картинка тоже)
Получился какой-то криптовыпуск: майнинг, ethereum, блокчейн, litecoin, страхование, фермы. И картинка тоже)
Вторник: FinWin, Тиньков, видеокарты для майнинга, криптобиржи, манифест блокчейн и даркнет
Вторник: FinWin, Тиньков, видеокарты для майнинга, криптобиржи, манифест блокчейн и даркнет
суббота, 17 июня 2017 г.
ЛЕТНИЕ БЛОКЧЕЙН МИТАПЫ
22 июня Калининград, Проспект Мира, 33 Клуб Калининград Сити Джаз London Pub ЛЕТНИЕ БЛОКЧЕЙН
Этим летом в Калининграде стартует серия блокчейн митапов от компании cyber•Fund. Кто не знает, митапы — это такие несерьёзные встречи на серьёзную тему. В нашем случае максимально непринужденные, но с мозговыносящим контентом.
Отличная возможность в неформальной обстановке послушать про блокчейн от спикеров, которые с 2011 года в этой теме и задать им любые вопросы.
Тех, кто регистрируется заранее, в LondonPub ждёт welcome drink, снеки, а так же напоминалка утром на почту;)
Добро пожаловать в мир блокчейна!
Второй митап — 22 июня в 19:00
Тема
Инвестирование в блокчейн-проекты
Спикер
КОНСТАНТИН ЛОМАШУК
CEO Satoshi•Fund
понедельник, 12 июня 2017 г.
https://ethereum.org
Build unstoppable applications Ethereum is a decentralized platform that runs smart contracts: applications that run exactly as programmed without any possibility of downtime, censorship, fraud or third party interference. These apps run on a custom built blockchain, an enormously powerful shared global infrastructure that can move value around and represent the ownership of property. This enables developers to create markets, store registries of debts or promises, move funds in accordance with instructions given long in the past (like a will or a futures contract) and many other things that have not been invented yet, all without a middle man or counterparty risk. The project was bootstrapped via an ether pre-sale during August 2014 by fans all around the world. It is developed by the Ethereum Foundation, a Swiss nonprofit, with contributions from great minds across the globe.
Learn Solidity, a new language for smart contracts: DESIGN AND ISSUE YOUR OWN CRYPTOCURRENCY Create a tradeable digital token that can be used as a currency, a representation of an asset, a virtual share, a proof of membership or anything at all. These tokens use a standard coin API, so your contract will be automatically compatible with any wallet, other contract or exchange also using this standard. The total amount of tokens in circulation can be set to a simple fixed amount or fluctuate based on any programmed ruleset.
CREATE YOUR OWN CRYPTO-CURRENCY WITH ETHEREUM
The Coin We are going to create a digital token. Tokens in the ethereum ecosystem can represent any fungible tradable good: coins, loyalty points, gold certificates, IOUs, in game items, etc. Since all tokens implement some basic features in a standard way, this also means that your token will be instantly compatible with the ethereum wallet and any other client or contract that uses the same standards. THE CODE If you just want to copy paste the code, then use this: pragma solidity ^0.4.8; contract tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData); } contract MyToken { /* Public variables of the token */ string public standard = 'Token 0.1'; string public name; string public symbol; uint8 public decimals; uint256 public totalSupply; /* This creates an array with all balances */ mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) public allowance; /* This generates a public event on the blockchain that will notify clients */ event Transfer(address indexed from, address indexed to, uint256 value); /* This notifies clients about the amount burnt */ event Burn(address indexed from, uint256 value); /* Initializes contract with initial supply tokens to the creator of the contract */ function MyToken( uint256 initialSupply, string tokenName, uint8 decimalUnits, string tokenSymbol ) { balanceOf[msg.sender] = initialSupply; // Give the creator all initial tokens totalSupply = initialSupply; // Update total supply name = tokenName; // Set the name for display purposes symbol = tokenSymbol; // Set the symbol for display purposes decimals = decimalUnits; // Amount of decimals for display purposes } /* Send coins */ function transfer(address _to, uint256 _value) { if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows balanceOf[msg.sender] -= _value; // Subtract from the sender balanceOf[_to] += _value; // Add the same to the recipient Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place } /* Allow another contract to spend some tokens in your behalf */ function approve(address _spender, uint256 _value) returns (bool success) { allowance[msg.sender][_spender] = _value; return true; } /* Approve and then communicate the approved contract in a single tx */ function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) { tokenRecipient spender = tokenRecipient(_spender); if (approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value, this, _extraData); return true; } } /* A contract attempts to get the coins */ function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead if (balanceOf[_from] < _value) throw; // Check if the sender has enough if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows if (_value > allowance[_from][msg.sender]) throw; // Check allowance balanceOf[_from] -= _value; // Subtract from the sender balanceOf[_to] += _value; // Add the same to the recipient allowance[_from][msg.sender] -= _value; Transfer(_from, _to, _value); return true; } function burn(uint256 _value) returns (bool success) { if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough balanceOf[msg.sender] -= _value; // Subtract from the sender totalSupply -= _value; // Updates totalSupply Burn(msg.sender, _value); return true; } function burnFrom(address _from, uint256 _value) returns (bool success) { if (balanceOf[_from] < _value) throw; // Check if the sender has enough if (_value > allowance[_from][msg.sender]) throw; // Check allowance balanceOf[_from] -= _value; // Subtract from the sender totalSupply -= _value; // Updates totalSupply Burn(_from, _value); return true; } } MINIMUM VIABLE TOKEN The token contract is quite complex. But in essence a very basic token boils down to this: contract MyToken { /* This creates an array with all balances */ mapping (address => uint256) public balanceOf; /* Initializes contract with initial supply tokens to the creator of the contract */ function MyToken( uint256 initialSupply ) { balanceOf[msg.sender] = initialSupply; // Give the creator all initial tokens } /* Send coins */ function transfer(address _to, uint256 _value) { if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows balanceOf[msg.sender] -= _value; // Subtract from the sender balanceOf[_to] += _value; // Add the same to the recipient } } UNDERSTANDING THE CODE Deploy New Contract So let's start with the basics. Open the Wallet app, go to the Contracts tab and then Deploy New Contract. On the Solidity Contract Source code text field, type the code below: contract MyToken { /* This creates an array with all balances */ mapping (address => uint256) public balanceOf; } A mapping means an associative array, where you associate addresses with balances. The addresses are in the basic hexadecimal ethereum format, while the balances are integers, ranging from 0 to 115 quattuorvigintillion. If you don't know how much a quattuorvigintillion is, it's many vigintillions more than anything you are planning to use your tokens for. The public keyword, means that this variable will be accessible by anyone on the blockchain, meaning all balances are public (as they need to be, in order for clients to display them). Edit New Contract If you published your contract right away, it would work but wouldn't be very useful: it would be a contract that could query the balance of your coin for any address–but since you never created a single coin, every one of them would return 0. So we are going to create a few tokens on startup. Add this code before the last closing bracket, just under the mapping.. line. function MyToken() { balanceOf[msg.sender] = 21000000; } Notice that the function MyToken has the same name as the contract MyToken. This is very important and if you rename one, you have to rename the other too: this is a special, startup function that runs only once and once only when the contract is first uploaded to the network. This function will set the balance of msg.sender, the user which deployed the contract, with a balance of 21 million. The choice of 21 million was rather arbitrary, and you can change it to anything you want in the code, but there's a better way: instead, supply it as a parameter for the function, like this: function MyToken(uint256 initialSupply) { balanceOf[msg.sender] = initialSupply; } Take a look at the right column besides the contract and you'll see a drop down, written pick a contract. Select the "MyToken" contract and you'll see that now it shows a section called Constructor parameters. These are changeable parameters for your token, so you can reuse the same code and only change these variables in the future. Edit New Contract Right now you have a functional contract that created balances of tokens but since there isn't any function to move it, all it does is stay on the same account. So we are going to implement that now. Write the following code before the last bracket. /* Send coins */ function transfer(address _to, uint256 _value) { /* Add and subtract new balances */ balanceOf[msg.sender] -= _value; balanceOf[_to] += _value; } This is a very straightforward function: it has a recipient and a value as the parameter and whenever someone calls it, it will subtract the _value from their balance and add it to the _to balance. Right away there's an obvious problem: what happens if the person wants to send more than it owns? Since we don't want to handle debt in this particular contract, we are simply going to make a quick check and if the sender doesn't have enough funds the contract execution will simply stop. It's also to check for overflows, to avoid having a number so big that it becomes zero again. To stop a contract execution mid execution you can either return or throw The former will cost less gas but it can be more headache as any changes you did to the contract so far will be kept. In the other hand, 'throw' will cancel all contract execution, revert any changes that transaction could have made and the sender will lose all ether he sent for gas. But since the Wallet can detect that a contract will throw, it always shows an alert, therefore preventing any ether to be spent at all. function transfer(address _to, uint256 _value) { /* Check if sender has balance and for overflows */ if (balanceOf[msg.sender] < _value || balanceOf[_to] + _value < balanceOf[_to]) throw; /* Add and subtract new balances */ balanceOf[msg.sender] -= _value; balanceOf[_to] += _value; } Now all that is missing is having some basic information about the contract. In the near future this can be handled by a token registry, but for now we'll add them directly to the contract: string public name; string public symbol; uint8 public decimals; And now we update the constructor function to allow all those variables to be set up at the start: /* Initializes contract with initial supply tokens to the creator of the contract */ function MyToken(uint256 initialSupply, string tokenName, uint8 decimalUnits, string tokenSymbol) { balanceOf[msg.sender] = initialSupply; // Give the creator all initial tokens name = tokenName; // Set the name for display purposes symbol = tokenSymbol; // Set the symbol for display purposes decimals = decimalUnits; // Amount of decimals for display purposes } Finally we now need something called Events. These are special, empty functions that you call to help clients like the Ethereum Wallet keep track of activities happening in the contract. Events should start with a capital letter. Add this line at the beginning of the contract to declare the event: event Transfer(address indexed from, address indexed to, uint256 value); And then you just need to add these two lines inside the "transfer" function: /* Notify anyone listening that this transfer took place */ Transfer(msg.sender, _to, _value); And now your token is ready! HOW TO DEPLOY If you aren't there already, open the Ethereum Wallet, go to the contracts tab and then click "deploy new contract". Now get the token source from above and paste it into the "Solidity source field". If the code compiles without any error, you should see a "pick a contract" drop down on the right. Get it and select the "MyToken" contract. On the right column you'll see all the parameters you need to personalize your own token. You can tweak them as you please, but for the purpose of this tutorial we recommend you to pick these parameters: 10,000 as the supply, any name you want, "%" for a symbol and 2 decimal places. Your app should be looking like this: Ethereum Wallet Screenshot 2015-12-03 at 3.50.36 PM 10 Scroll to the end of the page and you'll see an estimate of the computation cost of that contract and you can select a fee on how much ether you are willing to pay for it. Any excess ether you don't spend will be returned to you so you can leave the default settings if you wish. Press "deploy", type your account password and wait a few seconds for your transaction to be picked up. Ethereum Wallet Screenshot 2015-12-03 at 3.50.36 PM 11 You'll be redirected to the front page where you can see your transaction waiting for confirmations. Click the account named "Etherbase" (your main account) and after no more than a minute you should see that your account will show that you have 100% of the shares you just created. To send some to a few friends: select "send", and then choose which currency you want to send (ether or your newly created share), paste your friend's address on the "to" field and press "send". Screen Shot 2015-12-03 at 9.48.15 AM If you send it to a friend, they will not see anything in their wallet yet. This is because the wallet only tracks tokens it knows about, and you have to add these manually. Now go to the "Contracts" tab and you should see a link for your newly created contract. Click on it to go to its page. Since this is a very simple contract page there isn't much to do here, just click "copy address" and paste the contract address on a text editor, you'll need it shortly. To add a token to watch, go to the contracts page and then click "Watch Token". A pop-up will appear and you only need to paste the contract address. The token name, symbol and decimal number should be automatically filled but if it's not you can put anything you want (it will only affect how it displays on your wallet). Once you do this, you'll automatically be shown any balance you have of that token and you'll be able to send it to anyone else. Ethereum Wallet Beta 4 Screen Shot 2015-12-03 at 9.44.42 AM And now you have your own crypto token! Tokens by themselves can be useful as value exchange on local communities, ways to keep track of worked hours or other loyalty programs. But can we make a currency have an intrinsic value by making it useful? Improve your token You can deploy your whole crypto token without ever touching a line of code, but the real magic happens when you start customizing it. The following sections will be suggestions on functions you can add to your token to make it fit your needs more. CENTRALIZED ADMINISTRATOR All dapps are fully decentralized by default, but that doesn't mean they can't have some sort of central manager, if you want them to. Maybe you want the ability to mint more coins, maybe you want to ban some people from using your currency. You can add any of those features, but the catch is that you can only add them at the beginning, so all the token holders will always know exactly the rules of the game before they decide to own one. For that to happen, you need a central controller of currency. This could be a simple account, but could also be a contract and therefore the decision on creating more tokens will depend on the contract: if it's a democratic organization that can be up to vote, or maybe it can be just a way to limit the power of the token owner. In order to do that we'll learn a very useful property of contracts: inheritance. Inheritance allows a contract to acquire properties of a parent contract, without having to redefine all of them. This makes the code cleaner and easier to reuse. Add this code to the first line of your code, before contract MyToken {. contract owned { address public owner; function owned() { owner = msg.sender; } modifier onlyOwner { if (msg.sender != owner) throw; _; } function transferOwnership(address newOwner) onlyOwner { owner = newOwner; } } This creates a very basic contract that doesn't do anything except define some generic functions about a contract that can be "owned". Now the next step is just add the text is owned to your contract: contract MyToken is owned { /* the rest of the contract as usual */ This means that all the functions inside MyToken now can access the variable owner and the modifier onlyOwner. The contract also gets a function to transfer ownership. Since it might be interesting to set the owner of the contract at startup, you can also add this to the constructor function: function MyToken( uint256 initialSupply, string tokenName, uint8 decimalUnits, string tokenSymbol, address centralMinter ) { if(centralMinter != 0 ) owner = centralMinter; CENTRAL MINT Suppose you want the amount of coins in circulation to change. This is the case when your tokens actually represent an off blockchain asset (like gold certificates or government currencies) and you want the virtual inventory to reflect the real one. This might also be the case when the currency holders expect some control of the price of the token, and want to issue or remove tokens from circulation. First we need to add a variable to store the totalSupply and assign it in our constructor function. contract MyToken { uint256 public totalSupply; function MyToken(...) { totalSupply = initialSupply; ... } ... } Now let's add a new function finally that will enable the owner to create new tokens: function mintToken(address target, uint256 mintedAmount) onlyOwner { balanceOf[target] += mintedAmount; totalSupply += mintedAmount; Transfer(0, owner, mintedAmount); Transfer(owner, target, mintedAmount); } Notice the modifier onlyOwner on the end of the function name. This means that this function will be rewritten at compilation to inherit the code from the modifier onlyOwner we had defined before. This function's code will be inserted where there's an underline on the modifier function, meaning that this particular function can only be called by the account that is set as the owner. Just add this to a contract with an owner modifier and you'll be able to create more coins. FREEZING OF ASSETS Depending on your use case, you might need to have some regulatory hurdles on who can and cannot use your tokens. For that to happen, you can add a parameter that enables the contract owner to freeze or unfreeze assets. Add this variable and function anywhere inside the contract. You can put them anywhere but for good practice we recommend you put the mappings with the other mappings and events with the other events. mapping (address => bool) public frozenAccount; event FrozenFunds(address target, bool frozen); function freezeAccount(address target, bool freeze) onlyOwner { frozenAccount[target] = freeze; FrozenFunds(target, freeze); } With this code, all accounts are unfrozen by default but the owner can set any of them into a freeze state by calling Freeze Account. Unfortunately freezing has no practical effect, because we haven't added anything to the transfer function. We are changing that now: function transfer(address _to, uint256 _value) { if (frozenAccount[msg.sender]) throw; Now any account that is frozen will still have their funds intact, but won't be able to move them. All accounts are unfrozen by default until you freeze them, but you can easily revert that behavior into a whitelist where you need to manually approve every account. Just rename frozenAccount into approvedAccount and change the last line to: if (!approvedAccount[msg.sender]) throw; AUTOMATIC SELLING AND BUYING So far, you've relied on utility and trust to value your token. But if you want you can make the token's value be backed by ether (or other tokens) by creating a fund that automatically sells and buys them at market value. First, let's set the price for buying and selling: uint256 public sellPrice; uint256 public buyPrice; function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner { sellPrice = newSellPrice; buyPrice = newBuyPrice; } This is acceptable for a price that doesn't change very often, as every new price change will require you to execute a transaction and spend a bit of ether. If you want to have a constant floating price we recommend investigating standard data feeds The next step is making the buy and sell functions: function buy() payable returns (uint amount){ amount = msg.value / buyPrice; // calculates the amount if (balanceOf[this] < amount) throw; // checks if it has enough to sell balanceOf[msg.sender] += amount; // adds the amount to buyer's balance balanceOf[this] -= amount; // subtracts amount from seller's balance Transfer(this, msg.sender, amount); // execute an event reflecting the change return amount; // ends function and returns } function sell(uint amount) returns (uint revenue){ if (balanceOf[msg.sender] < amount ) throw; // checks if the sender has enough to sell balanceOf[this] += amount; // adds the amount to owner's balance balanceOf[msg.sender] -= amount; // subtracts the amount from seller's balance revenue = amount * sellPrice; if (!msg.sender.send(revenue)) { // sends ether to the seller: it's important throw; // to do this last to prevent recursion attacks } else { Transfer(msg.sender, this, amount); // executes an event reflecting on the change return revenue; // ends function and returns } } Notice that this will not create new tokens but change the balance the contract owns. The contract can hold both its own tokens and ether and the owner of the contract, while it can set prices or in some cases create new tokens (if applicable) it cannot touch the bank's tokens or ether. The only way this contract can move funds is by selling and buying them. Note Buy and sell "prices" are not set in ether, but in wei the minimum currency of the system (equivalent to the cent in the Euro and Dollar, or the Satoshi in Bitcoin). One ether is 1000000000000000000 wei. So when setting prices for your token in ether, add 18 zeros at the end. When creating the contract, send enough ether to it so that it can buy back all the tokens on the market otherwise your contract will be insolvent and your users won't be able to sell their tokens. The previous examples, of course, describe a contract with a single central buyer and seller, a much more interesting contract would allow a market where anyone can bid different prices, or maybe it would load the prices directly from an external source. AUTOREFILL Everytime you make a transaction on ethereum you need to pay a fee to the miner of the block that will calculate the result of your smart contract. While this might change in the future, for the moment fees can only be paid in ether and therefore all users of your tokens need it. Tokens in accounts with a balance smaller than the fee are stuck until the owner can pay for the necessary fee. But in some usecases, you might not want your users to think about ethereum, blockchain or how to obtain ether, so one possible approach would have your coin automatically refill the user balance as soon as it detects the balance is dangerously low. In order to do that, first you need to create a variable that will hold the threshold amount and a function to change it. If you don't know any value, set it to 5 finney (0.005 ether). uint minBalanceForAccounts; function setMinBalance(uint minimumBalanceInFinney) onlyOwner { minBalanceForAccounts = minimumBalanceInFinney * 1 finney; } Then, add this line to the transfer function so that the sender is refunded: /* Send coins */ function transfer(address _to, uint256 _value) { ... if(msg.sender.balance uint256) public balanceOf; mapping (address => mapping (address => uint256)) public allowance; /* This generates a public event on the blockchain that will notify clients */ event Transfer(address indexed from, address indexed to, uint256 value); /* Initializes contract with initial supply tokens to the creator of the contract */ function token( uint256 initialSupply, string tokenName, uint8 decimalUnits, string tokenSymbol ) { balanceOf[msg.sender] = initialSupply; // Give the creator all initial tokens totalSupply = initialSupply; // Update total supply name = tokenName; // Set the name for display purposes symbol = tokenSymbol; // Set the symbol for display purposes decimals = decimalUnits; // Amount of decimals for display purposes } /* Send coins */ function transfer(address _to, uint256 _value) { if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows balanceOf[msg.sender] -= _value; // Subtract from the sender balanceOf[_to] += _value; // Add the same to the recipient Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place } /* Allow another contract to spend some tokens in your behalf */ function approve(address _spender, uint256 _value) returns (bool success) { allowance[msg.sender][_spender] = _value; return true; } /* Approve and then communicate the approved contract in a single tx */ function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) { tokenRecipient spender = tokenRecipient(_spender); if (approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value, this, _extraData); return true; } } /* A contract attempts to get the coins */ function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { if (balanceOf[_from] < _value) throw; // Check if the sender has enough if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows if (_value > allowance[_from][msg.sender]) throw; // Check allowance balanceOf[_from] -= _value; // Subtract from the sender balanceOf[_to] += _value; // Add the same to the recipient allowance[_from][msg.sender] -= _value; Transfer(_from, _to, _value); return true; } /* This unnamed function is called whenever someone tries to send ether to it */ function () { throw; // Prevents accidental sending of ether } } contract MyAdvancedToken is owned, token { uint256 public sellPrice; uint256 public buyPrice; mapping (address => bool) public frozenAccount; /* This generates a public event on the blockchain that will notify clients */ event FrozenFunds(address target, bool frozen); /* Initializes contract with initial supply tokens to the creator of the contract */ function MyAdvancedToken( uint256 initialSupply, string tokenName, uint8 decimalUnits, string tokenSymbol ) token (initialSupply, tokenName, decimalUnits, tokenSymbol) {} /* Send coins */ function transfer(address _to, uint256 _value) { if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows if (frozenAccount[msg.sender]) throw; // Check if frozen balanceOf[msg.sender] -= _value; // Subtract from the sender balanceOf[_to] += _value; // Add the same to the recipient Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place } /* A contract attempts to get the coins */ function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { if (frozenAccount[_from]) throw; // Check if frozen if (balanceOf[_from] < _value) throw; // Check if the sender has enough if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows if (_value > allowance[_from][msg.sender]) throw; // Check allowance balanceOf[_from] -= _value; // Subtract from the sender balanceOf[_to] += _value; // Add the same to the recipient allowance[_from][msg.sender] -= _value; Transfer(_from, _to, _value); return true; } function mintToken(address target, uint256 mintedAmount) onlyOwner { balanceOf[target] += mintedAmount; totalSupply += mintedAmount; Transfer(0, this, mintedAmount); Transfer(this, target, mintedAmount); } function freezeAccount(address target, bool freeze) onlyOwner { frozenAccount[target] = freeze; FrozenFunds(target, freeze); } function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner { sellPrice = newSellPrice; buyPrice = newBuyPrice; } function buy() payable { uint amount = msg.value / buyPrice; // calculates the amount if (balanceOf[this] < amount) throw; // checks if it has enough to sell balanceOf[msg.sender] += amount; // adds the amount to buyer's balance balanceOf[this] -= amount; // subtracts amount from seller's balance Transfer(this, msg.sender, amount); // execute an event reflecting the change } function sell(uint256 amount) { if (balanceOf[msg.sender] < amount ) throw; // checks if the sender has enough to sell balanceOf[this] += amount; // adds the amount to owner's balance balanceOf[msg.sender] -= amount; // subtracts the amount from seller's balance if (!msg.sender.send(amount * sellPrice)) { // sends ether to the seller. It's important throw; // to do this last to avoid recursion attacks } else { Transfer(msg.sender, this, amount); // executes an event reflecting on the change } } } DEPLOYING Scroll down and you'll see an estimated cost for deployment. If you want you can change the slider to set a smaller fee, but if the price is too below the average market rate your transaction might take longer to pick up. Click Deploy and type your password. After a few seconds you'll be redirected to the dashboard and under Latest transactions you'll see a line saying "creating contract". Wait for a few seconds for someone to pick your transaction and then you'll see a slow blue rectangle representing how many other nodes have seen your transaction and confirmed them. The more confirmations you have, the more assurance you have that your code has been deployed. Created Token Click on the link that says Admin page and you'll be taken the simplest central bank dashboard in the world, where you can do anything you want with your newly created currency. On the left side under Read from contract you have all the options and functions you can use to read information from the contract, for free. If your token has an owner, it will display its address here. Copy that address and paste it on Balance of and it will show you the balance of any account (the balance is also automatically shown on any account page that has tokens). On the right side, under Write to Contract you'll see all the functions you can use to alter or change the blockchain in any way. These will cost gas. If you created a contract that allows you to mint new coins, you should have a function called "Mint Token". Select it. Manage central dollar Select the address where those new currencies will be created and then the amount (if you have decimals set at 2, then add 2 zeros after the amount, to create the correct quantity). On Execute from select the account that set as owner, leave the ether amount at zero and then press execute. After a few confirmations, the recipient balance will be updated to reflect the new amount. But your recipient wallet might not show it automatically: in order to be aware of custom tokens, the wallet must add them manually to a watch list. Copy your token address (at the admin page, press copy address) and send that to your recipient. If they haven't already they should go to the contracts tab, press Watch Token and then add the address there. Name, symbols and decimal amounts displayed can be customized by the end user, especially if they have other tokens with similar (or the same) name. The main icon is not changeable and users should pay attention to them when sending and receiving tokens to ensure they are dealing with the real deal and not some copycat token. add token Using your coin Once you've deployed your tokens, they will be added to your list of watched tokens, and the total balance will be shown on your account. In order to send tokens, just go to the Send tab and select an account that contains tokens. The tokens the account has will be listed just under Ether. Select them and then type the amount of tokens you want to send. If you want to add someone else's token, just go to the Contracts tab and click Watch token. For example, to add the Unicorn (🦄) token to your watch list, just add the address 0x89205A3A3b2A69De6Dbf7f01ED13B2108B2c43e7 and the remaining information will be loaded automatically. Click Ok and your token will be added. Invisible Unicorns Unicorn tokens are memorabilia created exclusively for those who have donated to the address 0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359 that is controlled by the Ethereum Foundation. For more information about them read it here Now what? You just learned how you can use ethereum to issue a token, that can represent anything you want. But what can you do with the tokens? You can use, for instance, the tokens to represent a share in a company or you can use a central committee to vote on when to issue new coins to control inflation. You can also use them to raise money for a cause, via a crowdsale. What will you build next?
Kickstart a project with a trustless crowdsale Do you already have ideas that you want to develop on Ethereum? Maybe you need help and some funds to bring them to life, but who would lend money to someone they don’t trust? Using Ethereum, you can create a contract that will hold a contributor's money until any given date or goal is reached. Depending on the outcome, the funds will either be released to the project owners or safely returned back to the contributors. All of this is possible without requiring a centralized arbitrator, clearing house or having to trust anyone. You can even use the token you created earlier to keep track of the distribution of rewards. Kickstart your project YOU CAN BUILD: A crowdfund to pre-sell a product A crowdsale to sell virtual shares in a blockchain organization An auction of a limited number of items
https://ethereum.org/crowdsale
https://ethereum.org/crowdsale
среда, 7 июня 2017 г.
Мультимаскинг от «Сибирского здоровья» – «умный» уход за кожей!
Мультимаскинг от «Сибирского здоровья» – «умный» уход за кожей! Мультимаксинг представляет принцип воздействия различных косметических средств на определенные зоны кожи. Главным образом имеется в виду Т-хона лица, щеки, подбородок, шея и декольте. Каждая из этих зон требует отдельного особого подхода и благодаря мультимаскингу уход за всеми этими типами участками можно осуществлять с максимальной эффективностью и экономией времени.
А в чем отличие каждой зоны?
· Т-зона, как правило, нуждается в глубоком очищении, сужении пор и регуляции выделения кожного секрета.
· Область щек и скул требует увлажнения и тонизирования.
· Шея и декольте. Данная зона нуждается в глубоком питании и тонизировании, отлично подойдут средства придающие коже упругость и эластичность, продлевая ее молодость.
Каковы плюсы мультимаскинга? Процедура мультимаскинга не только экономит ваше время, но и позволяет осуществлять «умный» уход за каждой зоной и обеспечить индивидуальное решение для каждого участка. Таким образом, где нужно пор будут глубоко очищены и сужены, либо наоборот - максимально увлажнены и насыщены питательными веществами. Вся процедура займет не более 15-20 минут. Специально для новичков разработана шпаргалка, в которой указаны средства, оптимальные для каждой зоны. Поделиться своими результатами и эффектом можно поделиться в соцсетях!
Регистрация в сибирском здоровье
https://ru.siberianhealth.com/ru/business/?ref=5862683
суббота, 3 июня 2017 г.
«Байкальская стирка» подошла к концу
02
Июня
Июня
«Байкальская стирка» подошла к концу
Не волнуйтесь, завершился межрегиональный конкурс, а не наша работа по спасению жемчужины Сибири. Программы Корпорации «Сибирское здоровье», направленные на сохранение уникального озера, продолжают развиваться, и «Байкальская стирка» – еще один шаг к его спасению.
Бизнес с сибирским здоровьеми
Что это за конкурс?
«Байкальская стирка» направлена на повышение информированности местных жителей и туристов о вреде, наносимом озеру фосфатами. Попадая в Байкал, эти вещества усиливают рост водорослей, нехарактерных для экосистемы озера, что ведет к ее изменению (к сведению: местные флора и фауна уникальны и не встречаются больше нигде в мире). Кроме того, фосфаты, обладая способностью проникать в кровь даже через неповрежденную кожу, наносят вред и здоровью человека.
Откуда в Байкале берутся фосфаты?
Они попадают в него со сточными водами близлежащих промышленных предприятий, а также вместе с пеной моющих средств, используемых местными жителями и туристами. Поел кашу, помыл тарелку средством с фосфатами – увеличил количество спирогиры в озере (читай: приблизил исчезновение крупнейшего естественного резервуара пресной воды на планете).
Расскажите подробнее о «Байкальской стирке» и ее результатах
В апреле этого года 12 команд из Республики Бурятии и Иркутской области провели мероприятия, в ходе которых познакомили детей и взрослых с проблемой эвтрофикации (насыщения водоемов биогенными элементами, сопровождающегося ростом биологической продуктивности водных бассейнов Байкала) и рассказали об опасности использования фосфатосодержащих средств для людей и природы. Более 2400 гостей приняли участие в различных мероприятиях, разработанных и проведенных командами-конкурсантами: мастер-классах, лекциях, открытых уроках, спектаклях агитбригад и соцопросах.
Какова главная цель «Байкальской стирки»?
Во-первых, донести до как можно большего числа людей информацию о способах защиты уникальной экосистемы озера. Во-вторых, начать спасение здесь и сейчас: профилактические и образовательные мероприятия среди туристов, а также привлечение внимания местных жителей к проблеме – уже успех. Кроме того, методические разработки участников (сценарии, планы уроков, презентации, видеоролики и т. п.) помогут другим активистам экологического просвещения рассказать детям и взрослым о важности использования безопасных для человека и природы моющих средств.
Как «Сибирское здоровье» помогло проведению конкурса?
Компания уже несколько лет принимает активное участие в спасении Байкала. Мы являемся спонсорами таких проектов, как «Сохраним эндемики Байкала!», «Байкал SOS», участвуем во многих других мероприятиях. Для победителей «Байкальской стирки» мы предоставили экологически чистые наборы средств серии Greenpin.
Помните, Байкал хранит более 19% мировых запасов пресной воды, и загрязнение этого озера – катастрофа планетарного масштаба.
Бизнес с сибирским здоровьеми
Присоединяйтесь к благотворительным проектам Корпорации «Сибирское здоровье» и используйте только экологически чистую продукцию – так вы внесете свой вклад в спасение Байкала.
Собственный бизнес с компанией сибирское здоровье
Постройте "Собственный бизнес с компание сибирское здоровье". Успех с "Сибирским здоровьем" возможен с первых шагов.
Вы пoлyчaeтe вoзмoжнocть пpиoбpeтaть пpoдукцию кoмпaнии пo выгoдным цeнaм co cкидкoй 25%. Xopoшee здopoвьe cтaнoвитcя eщe бoлee дocтyпным. Пpи этoм y Bac пoявляeтcя вoзмoжнocть иcпoльзoвaть бoнycныe нaчиcлeния yжe нa cлeдyющий дeнь!
Дaжe ecли вы нe плaниpyeтe бpocaть ocнoвнyю paбoтy и пpocтo ищeтe дoпoлнитeльный зapaбoтo?, y вac ecть вce шaнcы пoлyчaть oт 15 дo 30 тыcяч в мecяц. Oщyтив пepcпeктивы, вы нe зaxoтитe ocтaнaвливaтьcя нa дocтигнyтoм.
Ecли paбoтa в Cибиpcкoм Здopoвьe cтaнeт вaшим ocнoвным иcтoчникoм дoxoдa, и вы бyдeтe пocвящaть этoмy бoльшe вpeмeни – бyдьтe гoтoвы пoлyчaть oт 60 дo 150 тыcяч в мecяц.
Ecли вы гoтoвы paзвивaтьcя и идти вышe, y вac ecть шaнc дoбитьcя пpoдвижeния нa мeждyнapoднoм ypoвнe. B этoм cлyчae вaш дoxoд мoжeт нaчинaтьcя oт 300 тыcяч в мecяц.
Дaжe ecли вы нe плaниpyeтe бpocaть ocнoвнyю paбoтy и пpocтo ищeтe дoпoлнитeльный зapaбoтo?, y вac ecть вce шaнcы пoлyчaть oт 15 дo 30 тыcяч в мecяц. Oщyтив пepcпeктивы, вы нe зaxoтитe ocтaнaвливaтьcя нa дocтигнyтoм.
Ecли paбoтa в Cибиpcкoм Здopoвьe cтaнeт вaшим ocнoвным иcтoчникoм дoxoдa, и вы бyдeтe пocвящaть этoмy бoльшe вpeмeни – бyдьтe гoтoвы пoлyчaть oт 60 дo 150 тыcяч в мecяц.
Ecли вы гoтoвы paзвивaтьcя и идти вышe, y вac ecть шaнc дoбитьcя пpoдвижeния нa мeждyнapoднoм ypoвнe. B этoм cлyчae вaш дoxoд мoжeт нaчинaтьcя oт 300 тыcяч в мecяц.
Регистрация по ссылке https://ru.siberianhealth.com/ru/
Подписаться на:
Сообщения (Atom)