Thanks to the smart contracts on the Ethereum blockchain our platform is transparent and immutable.
Our rules are visible to everyone. These rules ensure that:
We don't have a white paper. We're fully digital and we don't use paper at all.
Everything has been written in the smart contract listed below.
pragma solidity ^0.4.4;
/**
* Ponzischeme.io - Published on 1st April 2018.
*
* Financial Pyramid for Dummies:
*
* A pyramid scheme is a business model that recruits members via a promise of payments
* for enrolling others into the scheme, rather than supplying investments or sale
* of products or services. [source: https://en.wikipedia.org/wiki/Pyramid_scheme]
*
* How Ponzischeme.io works in an example:
*
* 1. You buy a Ponzi Token with level 4 for 0.001 ETH
* 2. It's listed for sale automatically for 0.002 ETH
* 3. Previous owner is getting 0.0005 ETH immediately (he paid for his Ponzi Token exactly that)
* 4. He will receive the second half (minus fee) only after someone will buy it from you.
* 5. Thanks to this *successfull investment* strategy you can always return the Ponzi Token
* you own for a 50% of the price you paid. Do it only if you don't want to wait for
* a next buyer.
* 6. When someone will buy your Ponzi Token (for 0.002 ETH) you will receive 0.001 ETH immediately,
* and a second half (minus fee) when someone will buy it from him (*successfull investment*).
*
* Fee is charged only from a successful investment and is being used for rewarding owners of
* Ponzi Tokens with higher levels from the one purchased. There is no fee for purchasing
* the strongest token.
*
* In example listed above fee will looks as follows:
* - You bought a Ponzi Token with level 4 for a 0.001 ETH
* - Fee is 10% and it gives 0.0001 ETH
* - Owners of Ponzi Tokens with level 1, 2 and 3 will receive:
* - Level 1: 0.00005 (1/2)
* - Level 2: 0.000025 (1/4)
* - Level 3: 0.0000125 (1/8)
* - Level 1 (again): 0.0000125 (the rest after fee division)
* - Owners of levels 5 and 6 won't receive anything extra in this example.
*
* As you see, owning tokens with higher level is better (especially the first one).
*
* In code/comments we use words such as:
* Buyer - someone who is buying a Ponzi Token (he pays a price and becomes Owner)
* Owner - current owner of a token (he gets 1/2 of a price Buyer paid, and becomes Beneficient)
* Beneficient - previous owner of a token (he gets a second half of a price minus fee)
*/
//@TODO implement an ERC20 Token Interface to be listed on Coinbase
contract PonziScheme {
// How much fee is charged from a successful investment
uint8 feeInPercent = 10;
// Account of smart contract creator. It's is used only once in destructor.
address public masterAccount = msg.sender;
/********************
* PONZI TOKENS *
********************/
// How many tokens exists
uint8 tokens = 6;
// Tokens prices
uint[6] public tokensPrices;
// Their owners
address[6] public tokensOwners;
// Beneficient is a person who is waiting for a 90% reward from his/her token
address[6] public tokensBeneficients;
/**
* Smart Contract Constructor
*/
function PonziScheme() public {
for(uint8 i = 0; i < tokens; i++) {
// Starting price in WAI, equivalent to 0.0001 ETH
tokensPrices[i] = 100000000000000;
// At the beginning there is no owner.
tokensOwners[i] = address(0x0);
}
}
/**
* Transfer ETH if address not equal to 0x0
*/
function secureTransfer(address to, uint amount) private returns (bool success) {
if(to != address(0x0) && amount > 0) {
to.transfer(amount);
return true;
}
return false;
}
/**************
* MARKET *
**************/
/**
* Buy a Ponzi Token on the market.
*
* Note: I don't check if user is a current token owner beacuse
* he may want to pump the price.
*/
function buy(uint8 token) public payable {
// Check if token exists
require(token >= 0 && token < tokens);
// Check if user has sent correct amount of ETH
require(msg.value == tokensPrices[token]);
// How much I pay?
uint currentPrice = tokensPrices[token];
// How much owner paid?
uint ownerPrice = currentPrice/2;
/**
* Set new price
*/
tokensPrices[token] *= 2;
/**
* Calculate fees
*/
// Fee is charged from a successful investment (the one before this purchase).
uint fee = feeInPercent * ownerPrice / 100;
/**
* Payouts
*/
// Beneficient got earlier (as owner) 1/2 of the price and now
// I send him a second half minus fee.
if(tokensBeneficients[token] != address(0x0)) {
address beneficient = tokensBeneficients[token];
tokensBeneficients[token] = address(0x0);
uint missingAmount = ownerPrice/2 - fee;
secureTransfer(beneficient, missingAmount);
/* Success story */
/* Someone have got 90% return on his investment */
}
// Current owner gets here the same amount as he paid. He will get reward (90% more)
// when someone will buy token from the new buyer.
secureTransfer(tokensOwners[tokens], ownerPrice);
/* Little success story. Now he shouldn't lose his/her investment. */
// Every Ponzi Token HODLer with level higher than the current token will get part
// of a fee
uint ownersFee = fee;
uint8 i;
for(i = 0; i < token; i++) {
if(tokensOwners[i] == address(0x0)) continue;
ownersFee = ownersFee / 2;
fee -= ownersFee;
secureTransfer(tokensOwners[i], ownersFee);
}
// Owner of the first not empty token get the rest of fee
// It implies that there is no fee for purchasing the highest level token
for(i = 0; i < tokens; i++) {
if(tokensOwners[i] == address(0x0)) continue;
secureTransfer(tokensOwners[i], fee);
break;
}
/**
* Set the new owners
*/
tokensBeneficients[token] = tokensOwners[token];
tokensOwners[token] = msg.sender;
}
/**
* Return token and get 50% of investment back.
*
* Use it only when you don't want to wait for a new buyer.
* You will lose 50% of your investment beacuse the first half
* was sent to an old owner immediately after purchase.
*/
function cancelOrder(uint8 token) public {
// Check if token exists
require(token >= 0 && token <= tokens);
// Check if sender is token owner
require(msg.sender == tokensOwners[token]);
// Preventing reentrancy Attack
tokensOwners[token] = address(0x0);
// Return to user a half of the price he paid. We use 1/4 beacuse price
// is always increased by 2x after purchase.
uint amountToReturn = tokensPrices[token]/4;
secureTransfer(msg.sender, amountToReturn);
/* Sad story. He or she just lost 50% of his/her investment */
// Old owner becomes current owner.
tokensOwners[token] = tokensBeneficients[token];
// One who is returning token becomes Beneficient.
//
// If someone will buy token from a new owner, Beneficient will
// receive 1/2 of a price minus fee. His final losses could be lower,
// maybe ~25%.
tokensBeneficients[token] = msg.sender;
// Lower the price to a more attractive one.
tokensPrices[token] /= 2;
}
/**
* Destructor
*
* If something will go terribly wrong (e.g hackers will do their job)
* I will return all remaining ETH and delete contract.
*/
function thisDeveloperSucks() public {
require(msg.sender == masterAccount);
uint8 i;
for(i = 0; i < tokens; i++) {
// Owner paid 1/2 of the current price but we can return him
// only half of it. The first half was sent earlier to previous owner
// when he sold his Ponzi Token.
//
// You knew the risks, right?
uint amountToReturn = tokensPrices[i]/4;
secureTransfer(tokensOwners[i], amountToReturn);
}
// If there is ETH left return it to the first token owner and delete contract
for(i = 0; i < tokens; i++) {
if(tokensOwners[i] != address(0x0)) {
selfdestruct(tokensOwners[i]);
}
}
}
}
Start of the Trading Platform
Presence at some Crypto Conference
New partnership announcement
Music video premiere for "I Lost All My Money In a Ponzi Scheme"
Rebranding
We recommend you seek advice from a financial advisor to ensure that you understand the risks involved with missing the opportunity of a lifetime here.