Proposal: Introducing true utility in ERC20 tokens

The team has been working very hard to give the proposed Foundation a direction, sound footing and a set of procedures to follow. Within this domain, we found that the structure needs to come from the token itself. We have therefore come up with an innovation to add to the ERC20 standard.

We are proposing a recycle-harvest cycle within the Utility token.

The Problem: Becuase DIDs get used all the time by/for users whenever ID transactions take place, the world “may” run out of DIDs. Burning utility tokens for the sake of ID transfers will leave the supply of DIDs decreasing forever.

The solution — Recycle & Harvest: We are proposing a recycle functionality within the token: when a user does an ID transaction, their DIDs get recycled by the token. The Foundation will have the ability to “harvest” these tokens and present them again for usage by the public while still making sure that the original holders’ value of the token never decreases.

How does this work — Step by step:
1. A user does an ID transaction. Either the user or the subscriber (or both) pay in DIDs.
2. These DIDs are sent to a recycling pool within the token. They aren’t burnt or transferred.
3. The DIDs remain stored within the token contract marked as “recycled”.
4. After 1 year of a lockdown, the DID Foundation will have the opportunity to harvest these recycled tokens in case required and in case the supply wades.

What problmes does recycling a token solve?
- The total supply of the token remains the same.
- The world will never have to run out of DIDs which will become more like a commodity in the future.
- The Foundation will NEVER be allowed to resell harvested tokens below the market price. Thus still making sure that early birds get the best value.
- It makes a cycle and gives the whole scheme a defined direction.
- Makes the Foundation have access to assets in the form of DID tokens.

This is an innovation: The token contract itself stores all the recycled DIDs within itself. No other addresses or contracts - the token contract itself stores the DIDs. And after a set date, the token contract (when called) converts these recycled tokens into a useable form and gives it to the originator.

We are starting a discussion and would like the feedback of our community regarding this proposal for innovating the ERC20 standards to suit our needs.
We will be coming up with tokenology information as well as an improved business plan for the Foundation and the ID-economy that this change will bring.
All users are requested to pour in their ideas about the proposed improvement in the function and design of the token.

Proposed DID-2018 token source code:

contract DID is ERC20, SafeMath{

mapping(address => uint256) balances;

address public owner = msg.sender;

uint256 public totalSupply;

function balanceOf(address _owner) constant returns (uint256 balance) {

return balances[_owner];

}

function transfer(address _to, uint256 _value) returns (bool success){

balances[msg.sender] = safeSub(balances[msg.sender], _value);

balances[_to] = safeAdd(balances[_to], _value);

Transfer(msg.sender, _to, _value);

return true;

}

mapping (address => mapping (address => uint256)) allowed;

function transferFrom(address _from, address _to, uint256 _value) returns (bool success){

var _allowance = allowed[_from][msg.sender];

balances[_to] = safeAdd(balances[_to], _value);

balances[_from] = safeSub(balances[_from], _value);

allowed[_from][msg.sender] = safeSub(_allowance, _value);

Transfer(_from, _to, _value);

return true;

}

function approve(address _spender, uint256 _value) returns (bool success) {

allowed[msg.sender][_spender] = _value;

Approval(msg.sender, _spender, _value);

return true;

}

function allowance(address _owner, address _spender) constant returns (uint256 remaining) {

return allowed[_owner][_spender];

}

function burn(uint256 _value) returns (bool success) {

require(_value <= balances[msg.sender]);

address burner = msg.sender;

balances[burner] = safeSub(balances[burner],_value);

totalSupply=safeSub(totalSupply,_value);

Burn(burner, _value);

return true;

}

function recycle (uint256 _value) returns (bool success){

balances[msg.sender] = safeSub(balances[msg.sender], _value);

balances[address(this)] = safeAdd(balances[address(this)], _value);

Transfer(msg.sender, address(this), _value);

return true;

}

function harvest () returns (bool success) {

require(msg.sender == owner);

bool itsTime=false;

//Currently, the code checks for a 14th of Feb every year

if ( now >=1518566400 && now <=1518652799 ) //2018

itsTime=true;

if ( now >=1550102400 && now <=1550188799 )

itsTime=true;

if ( now >=1581638400 && now <=1581724799 )

itsTime=true;

if ( now >=1613260800 && now <=1613347199 )

itsTime=true;

if ( now >=1644796800 && now <=1644883199 )

itsTime=true;

if ( now >=1676332800 && now <=1676419199 )

itsTime=true;

if ( now >=1707868800 && now <=1707955199 )

itsTime=true;

if ( now >=1739491200 && now <=1739577599 )

itsTime=true;

if ( now >=1771027200 && now <=1771113599 )

itsTime=true;

if ( now >=1802563200 && now <=1802649599 )

itsTime=true;

if ( now >=1834099200 && now <=1834185599 )

itsTime=true;

if ( now >=1865721600 && now <=1865807999 )

itsTime=true;

if ( now >=1897257600 && now <=1897343999 )

itsTime=true;

if ( now >=1928793600 && now <=1928879999 )

itsTime=true;

if ( now >=1960329600 && now <=1960415999 )

itsTime=true;

if ( now >=1991952000 && now <=1992038399 )

itsTime=true;

if ( now >=2023488000 && now <=2023574399 )

itsTime=true;

if ( now >=2055024000 && now <=2055110399 )

itsTime=true;

if ( now >=2086560000 && now <=2086646399 )

itsTime=true;

if ( now >=2118182400 && now <=2118268799 ) //2037

itsTime=true;

require(itsTime);

uint256 Bal=balances[address(this)];

balances[owner] = safeAdd(Bal, balances[owner]);

balances[address(this)] = 0;

Transfer(address(this),owner,Bal);

return true;

}

string public name = “DID”;

string public symbol = “DID”;

uint public decimals = 18;

uint public initialSupply = 20000000000000000000000000000;

function DID() {

totalSupply = initialSupply;

balances[msg.sender] = initialSupply; // Give all of the initial tokens to the contract deployer.

}

}