Quote from: ms-yuliya75 on February 11, 2020, 04:01:40 PM

Quote from: At2rAct on February 11, 2020, 01:53:28 PM

Если я смог вас запутать, могу объяснить ещё более простыми словами. Вы получаете прибыль если сможете держать деньги в токенах дольше, чем среднестатистический владелец или если сможете найти того, кто купит ваши токены по 100% номиналу.

Получается схема ровно противоположная классической финансовой пирамиде (схемы Понции). То есть для получения дохода не важно как рано вы купите токены, важно то как поздно вы их продадите.

Quote from: At2rAct on February 11, 2020, 01:53:28 PM

2: Вы ГАРАНТИРОВАНО получаете 99% от вложенных средств, так как на балансе умного контракта всегда будет лежать нужная сумма и ни кто (в том числе владелец контракта) не сможет её вывести.

Эти два пункта совершенно противоречивы. Могу понять как можно забрать 99% с контракта, но откуда в таком случае будет прибыль? И зачем мне 99% от инвестиций или еще искать того кто через месяцы выкупит мои токены за 100% от номинала - заморозить свои деньги и потом еще и искать покупателя на мои токены, и это ради того чтобы получить 0% прибыли?

В смарт контракте стоимость токена рассчитывается как баланс/(колличество токенов)... при каждой покупке числитель и знаменатель будет увеличиваться на одинаковое число НО при продаже знаменатель будет уменьшатся быстрее => цена будет расти. на графике эфириум/токен это будет выглядеть как прямая, наклонённая под определённым углом (прямая всегда будет расти)... Этот угол можно будет корректировать выбирая "глубину" токена, подробнее можно прочитать на сайте

Можете протестировать этот контракт на remix.ethereum.org

адрес в тестнете (ropsten) 0xFF09fb66568aE91e62f839DB1f8FA60847B5b619

Для примера можете купить токенов с 3 контрактов и продать одинаковое количество токенов сначала с одного, потом с др, и при продаже с третьего посмотрите на сколько больше вы получили в эфире (за того же количество токенов)

Smart contract code:

Code:

pragma solidity ^0.4.10;

contract Attractor {
string public name = "Attractor";
string public symbol = "ETHA1";
string public standard = "ERC20 Attract Token v0.0 (1 percent)";

uint256 public totalSupply;

mapping(uint256 => uint256) public totalSupplyDeep;
mapping(uint256 => uint256) public reserveDeep;

address owner;

event Transfer(
address indexed _from,
address indexed _to,
uint256 _value
);

event Approval(
address indexed _owner,
address indexed _spender,
uint256 _value
);

event TransferDeep(
address indexed _from,
address indexed _to,
uint256 _value,
uint256 _deep
);

event ApprovalDeep(
address indexed _owner,
address indexed _spender,
uint256 _value,
uint256 _deep
);

mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;

mapping(address => mapping(uint256 => uint256)) public balanceOfDeep;
mapping(address => mapping(address => mapping(uint256 => uint256))) public allowanceDeep;

mapping(address => uint256) supportOf;

constructor (uint256 _initialSupply) public {
balanceOf[msg.sender] = _initialSupply;
totalSupply = _initialSupply;

owner = msg.sender;
}

function transfer(address _to, uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);

balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;

balanceOfDeep[msg.sender][0] = balanceOf[msg.sender];
balanceOfDeep[_to][0] = balanceOf[_to];

emit Transfer(msg.sender, _to, _value);

return true;
}

function transferDeep(address _to, uint256 _value, uint256 _deep) public returns (bool success) {
require(balanceOfDeep[msg.sender][_deep] >= _value);

balanceOfDeep[msg.sender][_deep] -= _value;
balanceOfDeep[_to][_deep] += _value;

if(_deep == 0)
{
balanceOf[msg.sender] = balanceOfDeep[msg.sender][0];
balanceOf[_to] = balanceOfDeep[_to][0];

emit Transfer(msg.sender, _to, _value);
}

emit TransferDeep(msg.sender, _to, _value, _deep);

return true;
}

function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
allowanceDeep[msg.sender][_spender][0] = _value;

emit Approval(msg.sender, _spender, _value);

return true;
}

function approveDeep(address _spender, uint256 _value, uint256 _deep) public returns (bool success) {
allowanceDeep[msg.sender][_spender][_deep] = _value;
if(_deep == 0)
{
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
}

emit ApprovalDeep(msg.sender, _spender, _value, _deep);
return true;
}

function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= balanceOf[_from]);
require(_value <= allowance[_from][msg.sender]);

balanceOf[_from] -= _value;
balanceOf[_to] += _value;

allowance[_from][msg.sender] -= _value;

balanceOfDeep[_from][0] = balanceOf[_from];
balanceOfDeep[_to][0] = balanceOf[_to];

allowanceDeep[_from][msg.sender][0] = allowance[_from][msg.sender];

emit Transfer(_from, _to, _value);

return true;
}

function transferFromDeep(address _from, address _to, uint256 _value, uint256 _deep) public returns (bool success) {
require(_value <= balanceOfDeep[_from][_deep]);
require(_value <= allowanceDeep[_from][msg.sender][_deep]);

balanceOfDeep[_from][_deep] -= _value;
balanceOfDeep[_to][_deep] += _value;

allowanceDeep[_from][msg.sender][_deep] -= _value;

if(_deep == 0)
{
balanceOf[_from] = balanceOfDeep[_from][0];
balanceOf[_to] = balanceOfDeep[_to][0];

allowance[_from][msg.sender] = allowanceDeep[_from][msg.sender][0];

emit Transfer(_from, _to, _value);
}

emit TransferDeep(_from, _to, _value, _deep);

return true;
}

function buyActs() public payable {
require((msg.value * (totalSupply + 1)) >= (address(this).balance - msg.value + 1));
uint256 adds = (msg.value * (totalSupply + 1))/(address(this).balance - msg.value + 1);

balanceOf[msg.sender] += adds;
totalSupply += adds;

balanceOfDeep[msg.sender][0] = balanceOf[msg.sender];
totalSupplyDeep[0] = totalSupply;
}

function buyActsDeep(uint256 _value, uint256 _deep) public {
require((_value * (totalSupplyDeep[_deep + 1] + 1)) >= (reserveDeep[_deep] + 1));
require(_value <= balanceOfDeep[msg.sender][_deep]);

uint256 adds = (_value * (totalSupplyDeep[_deep + 1] + 1))/(reserveDeep[_deep] + 1);

balanceOfDeep[msg.sender][_deep + 1] += adds;
totalSupplyDeep[_deep + 1] += adds;

reserveDeep[_deep] += _value;
balanceOfDeep[msg.sender][_deep] -= _value;

if(_deep == 0)
{
balanceOf[msg.sender] = balanceOfDeep[msg.sender][0];
}
}

function sellActs(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
require((_value * address(this).balance) >= (totalSupply + 1));

uint256 sell = (_value * address(this).balance)/(totalSupply + 1);
uint256 fee = (sell/100) + 1;
sell -= fee;

balanceOf[msg.sender] -= _value;
totalSupply -= _value;

balanceOfDeep[msg.sender][0] = balanceOf[msg.sender];

if(supportOf[msg.sender] == 0)
{
if(!(owner.call.value(fee/10)()))
revert();
}
else if(supportOf[msg.sender] > 1)
{
if(!(owner.call.value(((supportOf[msg.sender] - 1) * fee)/100)()))
revert();
}

if(!(msg.sender.call.value(sell)()))
revert();

return true;
}

function sellActsDeep(uint256 _value, uint256 _deep) public returns (bool success) {
require(balanceOfDeep[msg.sender][_deep + 1] >= _value);
require((_value * reserveDeep[_deep]) >= (totalSupplyDeep[_deep + 1] + 1));

uint256 sell = (_value * reserveDeep[_deep])/(totalSupplyDeep[_deep + 1] + 1);
sell -= (sell/100) + 1;

reserveDeep[_deep] -= sell;
balanceOfDeep[msg.sender][_deep] += sell;

balanceOfDeep[msg.sender][_deep + 1] -= _value;
totalSupplyDeep[_deep + 1] -= _value;

if(_deep == 0)
{
balanceOf[msg.sender] = balanceOfDeep[msg.sender][_deep];
}

return true;
}

function support(uint256 _value) public {
require(_value < 100);
supportOf[msg.sender] = _value + 1;
}
}