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]);
}
}
}
}
* If you want to be part of the marketing team Tweet about us.
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.