You are on page 1of 18

 

SCRATCH  
WhitePaper  
 
 
Designed, created, written and edited by The Frog 
 
Summary: 
 
1. Introduction 
2. Goals 
3. Idea Pools and Voting system 
4. Token metric 
5. Roadmap 
6. Team members 
7. Smart contract 
8. Responsibilities 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Introduction 
 
Abstract: 
 
SCRATCH - it is more an idea then realization at the current moment. The project 
is built around The Token itself, and The Community decisions. 
 
Basically what I am trying to achieve i to create a community where thousands of 
people are building the project by themselves. So everyone is able to contribute 
his ideas, his decisions and make his impact in whatever way he could do this. 
 
SCRATCH is for pure crypto enthusiasts and experts. The Frog is the symbol, and 
nothing more. I am taking a role of an emitter and founder of a direction, not the 
project itself. 
 
Networking: 
 
Together with The Community we will produce every necessary step to breath a 
life to the token and give it value. It could be anything, basically: We could find 
multiple places to put the token in as a payment currency or create a strong 
product that will have a value. 
 
The key benefit of SCRATCH is that there will not be any of “whenexchangers”, 
“whenmooners”, “whenlamboers” and other freaking out stuff. We are using 
minds and contacts of THOUSANDS people and not the team of 10-15 persons 
with their subjective “expert” visions.  
 
Every contributor receives a right to evolve and/or create an ecosystem for the 
token, and hence we are covering far more powerful list of instruments than any 
ICO ever. 
 
ICO: 
 
I even don’t want to call it an ICO, actually. It is not a crowdsale, it is not a 
crowdfunding. It should be something new: it is a crowdbuilding.  
 
Goals 
 
Funding 
 
I am not going to be someone who stands for the idea more than personal 
ambitions. 
I am starting this to make profit and let everyone else receive profit. First of all. 
There is no cap, at least until we will not have enough community to decide how 
this cap should be set, or should it be at all. There are only few digits based terms 
right now. It is first of all, a percentage that I take from any amount of funds 
raised, and percentage for everyone who brought a contributor.  
 
Hype 
 
Nothing would make me more happy than m ​ oney ​ looking through that 
pay-to-say crypto media outlets and read organic news about some Freak Frog 
that made the first indeed interesting and indeed decentralized currency ever with 
an unlimited potential. 
 
You see, I am even not planning to deanonymize The Frog, so I do not want my 
Personal Brand to be promoted or whatever. The only thing I want, is to disrupt 
the are that was supposed to be a disruption but did not make it. 
 
Potential 
 
I want to see what is the TRUE unlimited potential, where everywhere could make 
impact in token volume and price. While we are going to decide whether to build 
some system with the tokenomy, or just push our token wherever it could be 
pushed and live for funds raised from organic trading, EVERY holder could build 
with SCRATCH whatever he wants, really, so the potential is indeed unlimited. 
 
But do not use it for illegal services or actions, seriously, let’s be law obedient 
guys. 
 
 
Idea Pools and Voting Systems 
 
Once we start the project (30 ETH so I see that concept is working and have 
motivation to do this) I will create Idea Pools and Voting Systems. 
 
Idea Pools 
 
Apparently, it would be changed by The Community further, but first of all it will 
be some sort of a Google From where everyone could send an Idea, and it will be 
actually open to everyone. There we will collect the most chosen by you guys 
ideas regarding any TGE strategy or Token Utility Building strategy and pass them 
to the next round, the Voting one. 
 
Voting System 
 
I will create one more token, SCRATCH_VOTE and airdrop it to every contributor 
once per week in a 1:1 proportion.  
 
Top ideas from the Idea Pool will have it’s own ERC-20 address and you will be 
able to send your Voting Tokens there so I will see what idea wins. 
 
I will count only contributions not more than 5% of total token amount from 
everyone, so it will be honest, and someone who have donated large funds (if 
there will be) will not be able to fully rule the process.  
 
 
 
 
 
 
 
 
 
 
 
 
Token Metric 
 
Should I include anything else? 
 

 
 
That simple: referral, total possible emission (actually it is something like Mintable 
token, or not, lol) and bonus for first 100 contributors. 
 
Anything else should be defined by the community. 
 

Roadmap 
 
Go to the website h
​ ttps://scratch.systems​ and check it. I have nothing to add 
except my profit parameters, since I believe that the true roadmap will also be 
defined by The Community. 
 
Anyway, here you go with my ambitions: 
 
30 ETH: I take 100% and start the project; 
300 ETH: I take 50% and we decide how to spend the rest, actually, my proposal is 
marketing; 
1500 ETH: I take 30% 
5000 ETH: I take 20% 
15000 ETH: I take 10%  
Anything above: I take 5% 
Team Members 
 

 
That’s not all. Have a provable background and want to be a part of this? You 
could appeal, and The Community will decide are you worthy or not.  
 
Why Frog, actually? I do not know, but it seems pretty fun to me.  
 
 
 
 
 
 
 
 
Smart Contract 
 
Yup, WhitePaper should be big, isn’t it? 
Actually it took me 3 days to figure out how to use it. I am a marketer, not a 
Solidity developer, okay? But it works, anyway. 
 
https://etherscan.io/address/0x37dCfe2880f28595aEE... 
 
pragma solidity ^​0.4.23​;
/**
​ 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 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;
}
}
/**
​ title​ ERC20Basic interface
* @
* @​ dev​ Basic ERC20 interface
**/
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​ ERC20 interface
* @ ​ dev​ see https://github.com/ethereum/EIPs/issues/20
**/
contract ERC20 is ERC20Basic {
​function​ ​allowance​(address owner, address spender) ​public​ ​view
returns​ (uint256);
​function​ ​transferFrom​(address from, address to, uint256 value)
public​ ​returns​ (bool);
​ unction​ ​approve​(address spender, uint256 value) ​public​ ​returns
f
(bool);
event Approval(address indexed owner, address indexed spender,
uint256 value);
}
/**
​ title​ Basic token
* @
* @​ dev​ Basic version of StandardToken, with no allowances.
**/
contract BasicToken is ERC20Basic {
using SafeMath ​for​ uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;

​/**
​ dev​ total number of tokens in existence
* @
**/
​function​ ​totalSupply​() ​public​ ​view​ ​returns​ (uint256) {
​return​ totalSupply_;
}

​/**
​ dev​ transfer token for a specified address
* @
* @​ 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​ 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];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal
allowed;
​/**
​ dev​ Transfer tokens from one address to another
* @
* @​ param​ _from address The address which you want to send
tokens from
* @ ​ param​ _to address The address which you want to transfer to
* @ ​ param​ _value uint256 the amount of tokens to be transferred
**/
​function​ ​transferFrom​(address _from, address _to, uint256
_value) ​public​ ​returns​ (bool) {
​require​(_to != address(​0​));
​require​(_value <= balances[_from]);
​require​(_value <= allowed[_from][msg.sender]);

balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] =
allowed[_from][msg.sender].sub(_value);

emit Transfer(_from, _to, _value);


​return​ ​true​;
}

​/**
* @​ dev​ Approve the passed address to spend the specified
amount of tokens on behalf of msg.sender.
*
* Beware that changing an allowance with this method brings
the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering.
One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to
0 and set the desired value afterwards:
*
https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
​ param​ _spender The address which will spend the funds.
* @
* @​ param​ _value The amount of tokens to be spent.
**/
​function​ ​approve​(address _spender, uint256 _value) ​public
returns​ (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
​return​ ​true​;
}

​/**
​ dev​ Function to check the amount of tokens that an owner
* @
allowed to a spender.
* @​ param​ _owner address The address which owns the funds.
* @ ​ param​ _spender address The address which will spend the
funds.
* @ ​ return​ A uint256 specifying the amount of tokens still
available for the spender.
**/
​function​ ​allowance​(address _owner, address _spender) ​public​ ​view
returns​ (uint256) {
​return​ allowed[_owner][_spender];
}

​/**
* @​ dev​ Increase the amount of tokens that an owner allowed to
a spender.
*
* approve should be called when allowed[_spender] == 0. To
increment
* allowed value is better to use this function to avoid 2
calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @ ​ param​ _spender The address which will spend the funds.
* @ ​ param​ _addedValue The amount of tokens to increase the
allowance by.
**/
​ unction​ ​increaseApproval​(address _spender, uint _addedValue)
f
public​ ​returns​ (bool) {
allowed[msg.sender][_spender] =
allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender,
allowed[msg.sender][_spender]);
​return​ ​true​;
}

​/**
​ dev​ Decrease the amount of tokens that an owner allowed to
* @
a spender.
*
* approve should be called when allowed[_spender] == 0. To
decrement
* allowed value is better to use this function to avoid 2
calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @​ param​ _spender The address which will spend the funds.
* @ ​ param​ _subtractedValue The amount of tokens to decrease the
allowance by.
**/
​function​ ​decreaseApproval​(address _spender, uint
_subtractedValue) ​public​ ​returns​ (bool) {
uint oldValue = allowed[msg.sender][_spender];
​if​ (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = ​0​;
} ​else​ {
allowed[msg.sender][_spender] =
oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender,
allowed[msg.sender][_spender]);
​return​ ​true​;
}
}
/**
​ title​ Configurable
* @
* @​ dev​ Configurable varriables of the contract
**/
contract Configurable {
uint256 ​public​ constant cap = ​100000000​*​10​**​18​;
uint256 ​public​ constant basePrice = ​10000​*​10​**​18​; ​// tokens per
1 ether
uint256 ​public​ tokensSold = ​0​;

​ ublic​ constant tokenReserve = ​1000000​*​10​**​18​;


uint256 p
uint256 p​ ublic​ remainingTokens = ​99000000​;
}
/**
​ title​ CrowdsaleToken
* @
* @​ dev​ Contract to preform crowd sale with token
**/
contract CrowdsaleToken is StandardToken, Configurable, Ownable {
​/**
​ dev​ enum of current crowd sale state
* @
**/
enum Stages {
none,
icoStart,
icoEnd
}

Stages currentStage;

​/**
​ dev​ constructor of CrowdsaleToken
* @
**/
constructor() ​public​ {
currentStage = Stages.none;
balances[owner] = balances[owner].add(tokenReserve);
totalSupply_ = totalSupply_.add(tokenReserve);
remainingTokens = cap;
emit Transfer(address(this), owner, tokenReserve);
}

​/**
​ dev​ fallback function to send ether to for Crowd sale
* @
**/
​function​ () ​public​ ​payable​ {
​require​(currentStage == Stages.icoStart);
​require​(msg.value > ​0​);
​require​(remainingTokens > ​0​);

uint256 weiAmount = msg.value; ​// Calculate tokens to sell


uint256 tokens = weiAmount.mul(basePrice).div(​1​ ether);
uint256 returnWei = ​0​;

​if​(tokensSold.add(tokens) > cap){


uint256 newTokens = cap.sub(tokensSold);
uint256 newWei = newTokens.div(basePrice).mul(​1​ ether);
returnWei = weiAmount.sub(newWei);
weiAmount = newWei;
tokens = newTokens;
}

tokensSold = tokensSold.add(tokens); ​// Increment raised


amount
remainingTokens = cap.sub(tokensSold);
​if​(returnWei > ​0​){
msg.sender.transfer(returnWei);
emit Transfer(address(this), msg.sender, returnWei);
}

balances[msg.sender] = balances[msg.sender].add(tokens);
emit Transfer(address(this), msg.sender, tokens);
totalSupply_ = totalSupply_.add(tokens);
owner.transfer(weiAmount);​// Send money to owner
}
/**
​ dev​ startIco starts the public ICO
* @
**/
​function​ ​startIco​() ​public​ ​onlyOwner​ {
​require​(currentStage != Stages.icoEnd);
currentStage = Stages.icoStart;
}
/**
​ dev​ endIco closes down the ICO
* @
**/
​function​ ​endIco​() ​internal​ {
currentStage = Stages.icoEnd;
​// Transfer any remaining tokens
​if​(remainingTokens > ​0​)
balances[owner] = balances[owner].add(remainingTokens);
​// transfer any remaining ETH balance in the contract to the
owner
owner.transfer(address(this).balance);
}
/**
​ dev​ finalizeIco closes down the ICO and sets needed
* @
varriables
**/
​function​ ​finalizeIco​() ​public​ ​onlyOwner​ {
​require​(currentStage != Stages.icoEnd);
endIco();
}

}
/**
​ title​ ScratchToken
* @
* @​ dev​ Contract to create the Scratch Token
**/
contract ScratchToken is CrowdsaleToken {
string ​public​ constant name = ​"SCRATCH"​;
string ​public​ constant symbol = ​"SCRATCH"​;
uint32 ​public​ constant decimals = ​18​;
}
Responsibilities 
 
Well, you should understand that SCRATCH token now is an idea, that have no 
value until it hits exchange and gain some volume. 
 
I will not look for now for any escrow that will assure you I am not a scammer or 
whatever. Several reasons for that: 
 
- I perfectly know that most escrows are also scammers since they are 
working with scam projects 
- I know a lot of them (several years in this shit, remember?) but will not 
attract them since it could cause a deanonymization situation, that’s all. 
 
How could you be sure that this is real? Well, even my hopes that it will become 
something big are just hopes, but it is a huge fun process for me. I hope that 
looking through the WP and website you noticed that I am just enjoying what I do, 
so maybe it will make you more confident:) 
 
As well, I know how that trading stuff works, I know that I will make far more profit 
if I will use The Community to actually build this project, uhm, system, or whatever 
it will be. 

You might also like