Y’know all these OneCoin factors y’all been investing in since 2014 on that non-existent blockchain?
Yeah… overlook about them. Over the following yr OneCoin desires you to speculate much more cash in a to be launched OFC ERC20 token.
Earlier at the moment OneCoin revealed it’s newest “large announcement”, concerning what many determined buyers have been hoping for a OneCoin factors public buying and selling date.
That didn’t occur, with OneCoin as a substitute asserting a brand new OFC ERC20 token ICO.
With out getting too technical, OFC might be a brand new set of factors obtainable for OneCoin associates to spend money on.
Relatively than use OneCoin’s non-existent blockchain, as a substitute OFC might be launched on the Ethereum platform. As a result of y’know, “future of cash” and all that.
Worse nonetheless, regardless of taking just a few minutes to arrange, OneCoin are going to drip feed OFC tokens to buyers until October, 2019.
So yeah, anybody eager to publicly commerce their OneCoin factors goes to have to attend not less than one other eleven months – after which there’ll little doubt be another distraction pulled out.
Or Bulgarian authorities might stand up off their lazy asses and do their job. Simply sayin’.
OneCoin intend to start out promoting pre-generated OFC tokens from October eighth, 2018 until January seventh, 2019.
120 billion pre-generated OFC tokens might be flogged to what stays of the gullible OneCoin affiliate base for €0.02 to €0.06 EUR.
In April 2019 the corporate will launch 30% of invested tokens, with the ultimate quantities launched on October 2019.
OneCoin after all present no cause for delaying giving out pre-generated and already invested in OFC tokens by 9 months.
Quite a lot of third-party exchanges are featured on the OneCoin ICO web site as “exchanges that we’re contacting”.
This means the corporate hopes to checklist its ERC20 OFC token publicly in some unspecified time in the future.
Or to have a look at it one other manner, affirmation that just about OneCoin’s final 4 years have been nothing greater than one large Ponzi lie.
Naturally no third-party change can checklist factors tracked on a SQL database, therefore now we have this new OFC token nonsense.
Persuade just a few shady exchanges to checklist the token, convert current OneCoin factors to pre-generated OFC tokens in some unspecified time in the future …
Please, somebody cease me if I’m fallacious.
As for the worth of OFC inevitably dumping, OneCoin couldn’t care much less if it collapses.
The corporate already has your cash – what are you gonna do about it?
Replace twenty third August 2018 – In a probable try to keep away from scrutiny, OneCoin has eliminated the OFC ERC20 sensible contract code from their web site.
Right here it’s the code as initially printed;
pragma solidity ^0.4.19;
/**
* @title ERC20Basic
* @dev Less complicated model of ERC20 interface
* @dev see EIPs GitHub hyperlink
*/
contract ERC20Basic {
perform totalSupply() public view returns (uint256);
perform balanceOf(tackle who) public view returns (uint256);
perform switch(tackle to, uint256 worth) public returns (bool);
occasion Switch(tackle listed from, tackle listed to, uint256 worth);
}/**
* @title ERC20 interface
* @dev see EIPs GitHub hyperlink
*/
contract ERC20 is ERC20Basic {
perform allowance(tackle proprietor, tackle spender) public view returns (uint256);
perform transferFrom(tackle from, tackle to, uint256 worth) public returns (bool);
perform approve(tackle spender, uint256 worth) public returns (bool);
occasion Approval(tackle listed proprietor, tackle listed spender, uint256 worth);
}/**
* @title SafeMath
* @dev Math operations with security checks that throw on error
*/
library SafeMath {/**
* @dev Multiplies two numbers, throws on overflow.
*/
perform mul(uint256 a, uint256 b) inner pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}/**
* @dev Integer division of two numbers, truncating the quotient.
*/
perform div(uint256 a, uint256 b) inner pure returns (uint256) {
// assert(b > 0); // Solidity mechanically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no such thing as a case wherein this doesn’t maintain
return a / b;
}/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is bigger than minuend).
*/
perform sub(uint256 a, uint256 b) inner pure returns (uint256) {
assert(b
return a – b;
}/**
* @dev Provides two numbers, throws on overflow.
*/
perform add(uint256 a, uint256 b) inner pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}/**
* @title Fundamental token
* @dev Fundamental model of StandardToken, with no allowances.
*/
contract BasicToken is ERC20Basic {
utilizing SafeMath for uint256;mapping(tackle => uint256) balances;
uint256 totalSupply_;
/**
* @dev whole variety of tokens in existence
*/
perform totalSupply() public view returns (uint256) {
return totalSupply_;
}/**
* @dev switch token for a specified tackle
* @param _to The tackle to switch to.
* @param _value The quantity to be transferred.
*/
perform switch(tackle _to, uint256 _value) public returns (bool) {
require(_to != tackle(0));
require(_valuebalances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Switch(msg.sender, _to, _value);
return true;
}/**
* @dev Will get the steadiness of the desired tackle.
* @param _owner The tackle to question the the steadiness of.
* @return An uint256 representing the quantity owned by the handed tackle.
*/
perform balanceOf(tackle _owner) public view returns (uint256 steadiness) {
return balances[_owner];
}}
/**
* @title Normal ERC20 token
*
* @dev Implementation of the fundamental commonplace token.
* @dev EIPs GitHub hyperlink
* @dev Primarily based on code by FirstBlood: GitHub FirstBlood hyperlink
*/
contract StandardToken is ERC20, BasicToken {mapping (tackle => mapping (tackle => uint256)) inner allowed;
/**
* @dev Switch tokens from one tackle to a different
* @param _from tackle The tackle which you need to ship tokens from
* @param _to tackle The tackle which you need to switch to
* @param _value uint256 the quantity of tokens to be transferred
*/
perform transferFrom(tackle _from, tackle _to, uint256 _value) public returns (bool) {
require(_to != tackle(0));
require(_value
require(_valuebalances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Switch(_from, _to, _value);
return true;
}/**
* @dev Approve the handed tackle to spend the desired quantity of tokens on behalf of msg.sender.
*
* Beware that altering an allowance with this technique brings the danger that somebody could use each the previous
* and the brand new allowance by unlucky transaction ordering. One attainable answer to mitigate this
* race situation is to first cut back the spender’s allowance to 0 and set the specified worth afterwards:
* EIPs GitHub hyperlink
* @param _spender The tackle which can spend the funds.
* @param _value The quantity of tokens to be spent.
*/
perform approve(tackle _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}/**
* @dev Operate to examine the quantity of tokens that an proprietor allowed to a spender.
* @param _owner tackle The tackle which owns the funds.
* @param _spender tackle The tackle which can spend the funds.
* @return A uint256 specifying the quantity of tokens nonetheless obtainable for the spender.
*/
perform allowance(tackle _owner, tackle _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}/**
* @dev Improve the quantity of tokens that an proprietor allowed to a spender.
*
* approve needs to be known as when allowed[_spender] == 0. To increment
* allowed worth is healthier to make use of this perform to keep away from 2 calls (and wait till
* the primary transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The tackle which can spend the funds.
* @param _addedValue The quantity of tokens to extend the allowance by.
*/
perform increaseApproval(tackle _spender, uint _addedValue) 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 Lower the quantity of tokens that an proprietor allowed to a spender.
*
* approve needs to be known as when allowed[_spender] == 0. To decrement
* allowed worth is healthier to make use of this perform to keep away from 2 calls (and wait till
* the primary transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The tackle which can spend the funds.
* @param _subtractedValue The quantity of tokens to lower the allowance by.
*/
perform decreaseApproval(tackle _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 Ownable
* @dev The Ownable contract has an proprietor tackle, and offers fundamental authorization management
* capabilities, this simplifies the implementation of “person permissions”.
*/
contract Ownable {
tackle public proprietor;occasion OwnershipTransferred(tackle listed previousOwner, tackle listed newOwner);
/**
* @dev The Ownable constructor units the unique `proprietor` of the contract to the sender
* account.
*/
perform Ownable() public {
proprietor = msg.sender;
}/**
* @dev Throws if known as by any account aside from the proprietor.
*/
modifier onlyOwner() {
require(msg.sender == proprietor);
_;
}/**
* @dev Permits the present proprietor to switch management of the contract to a newOwner.
* @param newOwner The tackle to switch possession to.
*/
perform transferOwnership(tackle newOwner) public onlyOwner {
require(newOwner != tackle(0));
emit OwnershipTransferred(proprietor, newOwner);
proprietor = newOwner;
}}
contract OFC is Ownable, StandardToken {
string public fixed identify = “OneCoin”;
string public fixed image = “OFC”;
uint8 public fixed decimals = 7;uint256 public fixed INITIAL_SUPPLY = (120000 * (10**6)) * (10 ** uint256(decimals));
constructor() public {
totalSupply_ = INITIAL_SUPPLY;
balances[this] = INITIAL_SUPPLY;
emit Switch(tackle(0), this, INITIAL_SUPPLY);
}//sending tokens from contract tackle
perform ship(tackle to, uint quantity) public onlyOwner {
require(to != tackle(0));
require(quantity > 0);// SafeMath.sub will throw if there may be not sufficient steadiness.
balances[this] = balances[this].sub(quantity);
balances[to] = balances[to].add(quantity);
emit Switch(this, to, quantity);
}//mining tokens and sending to handle
perform mint(tackle to, uint quantity) public onlyOwner {
require(to != tackle(0));
require(quantity > 0);totalSupply_ = totalSupply_.add(quantity);
balances[to] = balances[to].add(quantity);
emit Switch(tackle(0), to, quantity);
}//burning tokens from tackle
perform burn(tackle from, uint quantity) public onlyOwner {
require(from != tackle(0));
require(quantity > 0);// SafeMath.sub will throw if there may be not sufficient steadiness.
totalSupply_ = totalSupply_.sub(quantity);
balances[from] = balances[from].sub(quantity);
emit Switch(from, tackle(0), quantity);
}perform() public payable {}
//Sendin Ethers
perform sendEther(tackle to, uint quantity) public onlyOwner {
require(to != tackle(0));
require(quantity > 0);
to.switch(quantity);
}}
Solidity and ERC20Basic look like free ERC20 token scripts obtainable on GitHub.
Observe that I needed to edit the GitHub hyperlinks because the URLs have been too lengthy of their unique textual content format (was breaking the web site for cell customers).
Replace twenty third August 2018 #2 – The source-code of the OneCoin ICO web site reveals the corporate employed to create the OFC sensible contract:
In an try to masks the supply, the remainder of the picture URLs on the web site have been encoded. It seems nevertheless that somebody forgot to encode the previous few picture URLs. Ruhroh!
The “ICO Promotion” web site belongs to ICODA, who describe themselves as “the ICO Digital Company”.
The corporate markets “executed for you” sensible contract creation, ICO web site creation and white paper improvement and itemizing on exchanges providers.
Who owns ICODA just isn’t disclosed on the corporate web site. A number of ICODA workers are listed on LinkedIn, with disinticly Russian sounding names (Evgeniy Stepanov, Игорь Чеканов, Ruslan Pivnev, Vladimir Z. and Ratislav Yankovskiy).
How a lot OneCoin paid ICODA to provide you with their OFC ERC20 token is unclear.