Professional Documents
Culture Documents
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);
/**
* @ 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;
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);
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.