cicnet/erc20-demurrage-token
5
0
Fork 0
mirror of git://holbrook.no/erc20-demurrage-token synced 2024-12-22 20:07:32 +01:00
Code Issues Packages Projects Releases Wiki Activity

Compact words, add demurragemodifier to redistribution word

Browse Source
This commit is contained in:
nolash 2021-02-06 19:10:27 +01:00
parent 0f816ebdc5
commit 2ad59df9c9
Signed by: lash
GPG Key ID: 21D2E7BB88C2A746
2 changed files with 84 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
python/tests/test_redistribution.py
View File

@ -84,14 +84,14 @@ class Test(unittest.TestCase):
self.eth_tester.time_travel(self.start_time + 61) self.eth_tester.time_travel(self.start_time + 61)
redistribution = self.contract.functions.redistributions(0).call(); redistribution = self.contract.functions.redistributions(0).call();
self.assertEqual(redistribution.hex(), '000000000100000000000000000000000000000000001e848000000000000001') self.assertEqual(redistribution.hex(), '000000000000000000000000f42400000000010000000000001e848000000001')
tx_hash = self.contract.functions.mintTo(self.w3.eth.accounts[0], 1000000).transact() tx_hash = self.contract.functions.mintTo(self.w3.eth.accounts[0], 1000000).transact()
r = self.w3.eth.getTransactionReceipt(tx_hash) r = self.w3.eth.getTransactionReceipt(tx_hash)
self.assertEqual(r.status, 1) self.assertEqual(r.status, 1)
redistribution = self.contract.functions.redistributions(1).call() redistribution = self.contract.functions.redistributions(1).call()
self.assertEqual(redistribution.hex(), '000000000000000000000000000000000000000000002dc6c000000000000002') self.assertEqual(redistribution.hex(), '000000000000000000000000ef4200000000000000000000002dc6c000000002')
def test_redistribution_balance_on_zero_participants(self): def test_redistribution_balance_on_zero_participants(self):

117
solidity/RedistributedDemurrageToken.sol
View File

@ -18,8 +18,10 @@ contract RedistributedDemurrageToken {
uint256 public immutable taxLevel; // PPM per MINUTE uint256 public immutable taxLevel; // PPM per MINUTE
uint256 public demurrageModifier; // PPM uint128(block) | uint128(ppm) uint256 public demurrageModifier; // PPM uint128(block) | uint128(ppm)
bytes32[] public redistributions; // uint1(isFractional) | uint1(unused) | uint38(participants) | uint160(value) | uint56(period) //bytes32[] public redistributions; // uint1(isFractional) | uint1(unused) | uint38(participants) | uint160(value) | uint56(period)
mapping (address => bytes32) account; // uint20(unused) | uint56(period) | uint160(value) bytes32[] public redistributions; // uint1(isFractional) | uint95(unused) | uint20(demurrageModifier) | uint36(participants) | uint72(value) | uint32(period)
//mapping (address => bytes32) account; // uint20(unused) | uint56(period) | uint160(value)
mapping (address => bytes32) account; // uint152(unused) | uint32(period) | uint72(value)
mapping (address => bool) minter; mapping (address => bool) minter;
mapping (address => mapping (address => uint256 ) ) allowance; // holder -> spender -> amount (amount is subject to demurrage) mapping (address => mapping (address => uint256 ) ) allowance; // holder -> spender -> amount (amount is subject to demurrage)
@ -44,7 +46,7 @@ contract RedistributedDemurrageToken {
demurrageModifier |= (1 << 128); demurrageModifier |= (1 << 128);
taxLevel = _taxLevelMinute; // 38 decimal places taxLevel = _taxLevelMinute; // 38 decimal places
sinkAddress = _defaultSinkAddress; sinkAddress = _defaultSinkAddress;
bytes32 initialRedistribution = toRedistribution(0, 0, 1); bytes32 initialRedistribution = toRedistribution(0, 1000000, 0, 1);
redistributions.push(initialRedistribution); redistributions.push(initialRedistribution);
minimumParticipantSpend = 10 ** uint256(_decimals); minimumParticipantSpend = 10 ** uint256(_decimals);
} }
@ -77,13 +79,17 @@ contract RedistributedDemurrageToken {
/// Balance unmodified by demurrage /// Balance unmodified by demurrage
function getBaseBalance(address _account) private view returns (uint256) { function getBaseBalance(address _account) private view returns (uint256) {
return uint256(account[_account]) & 0x00ffffffffffffffffffffffffffffffffffffffff; //return uint256(account[_account]) & 0x00ffffffffffffffffffffffffffffffffffffffff;
return uint256(account[_account]) & 0xffffffffffffffffff;
} }
/// Increases base balance for a single account /// Increases base balance for a single account
function increaseBaseBalance(address _account, uint256 _delta) private returns (bool) { function increaseBaseBalance(address _account, uint256 _delta) private returns (bool) {
uint256 oldBalance; uint256 oldBalance;
uint256 newBalance; uint256 newBalance;
uint256 workAccount;
workAccount = uint256(account[_account]); // | (newBalance & 0xffffffffffffffffff);
if (_delta == 0) { if (_delta == 0) {
return false; return false;
@ -92,8 +98,12 @@ contract RedistributedDemurrageToken {
oldBalance = getBaseBalance(_account); oldBalance = getBaseBalance(_account);
newBalance = oldBalance + _delta; newBalance = oldBalance + _delta;
require(uint160(newBalance) > uint160(oldBalance), 'ERR_WOULDWRAP'); // revert if increase would result in a wrapped value require(uint160(newBalance) > uint160(oldBalance), 'ERR_WOULDWRAP'); // revert if increase would result in a wrapped value
account[_account] &= bytes32(0xffffffffffffffffffffffff0000000000000000000000000000000000000000); //account[_account] &= bytes32(0xfffffffffffffffffffffff0000000000000000000000000000000000000000);
account[_account] |= bytes32(newBalance & 0x00ffffffffffffffffffffffffffffffffffffffff); //account[_account] = bytes32(uint256(account[_account]) & 0xfffffffffffffffffffffffffffffffffffffffffffff000000000000000000);
workAccount &= 0xfffffffffffffffffffffffffffffffffffffffffffff000000000000000000;
//account[_account] |= bytes32(newBalance & 0x00ffffffffffffffffffffffffffffffffffffffff);
workAccount |= newBalance & 0xffffffffffffffffff;
account[_account] = bytes32(workAccount);
return true; return true;
} }
@ -101,6 +111,9 @@ contract RedistributedDemurrageToken {
function decreaseBaseBalance(address _account, uint256 _delta) private returns (bool) { function decreaseBaseBalance(address _account, uint256 _delta) private returns (bool) {
uint256 oldBalance; uint256 oldBalance;
uint256 newBalance; uint256 newBalance;
uint256 workAccount;
workAccount = uint256(account[_account]); // | (newBalance & 0xffffffffffffffffff);
if (_delta == 0) { if (_delta == 0) {
return false; return false;
@ -109,8 +122,11 @@ contract RedistributedDemurrageToken {
oldBalance = getBaseBalance(_account); oldBalance = getBaseBalance(_account);
require(oldBalance >= _delta, 'ERR_OVERSPEND'); // overspend guard require(oldBalance >= _delta, 'ERR_OVERSPEND'); // overspend guard
newBalance = oldBalance - _delta; newBalance = oldBalance - _delta;
account[_account] &= bytes32(0xffffffffffffffffffffffff0000000000000000000000000000000000000000); //account[_account] &= bytes32(0xffffffffffffffffffffffff0000000000000000000000000000000000000000);
account[_account] |= bytes32(newBalance & 0x00ffffffffffffffffffffffffffffffffffffffff); workAccount &= 0xfffffffffffffffffffffffffffffffffffffffffffff000000000000000000;
//account[_account] |= bytes32(newBalance & 0x00ffffffffffffffffffffffffffffffffffffffff);
workAccount |= newBalance & 0xffffffffffffffffff;
account[_account] = bytes32(workAccount);
return true; return true;
} }
@ -132,28 +148,35 @@ contract RedistributedDemurrageToken {
} }
// Deserializes the redistribution word // Deserializes the redistribution word
function toRedistribution(uint256 _participants, uint256 _value, uint256 _period) private pure returns(bytes32) { // uint1(isFractional) | uint95(unused) | uint20(demurrageModifier) | uint36(participants) | uint72(value) | uint32(period)
function toRedistribution(uint256 _participants, uint256 _demurrageModifierPpm, uint256 _value, uint256 _period) private pure returns(bytes32) {
bytes32 redistribution; bytes32 redistribution;
redistribution |= bytes32((_participants & 0x7fffffffff) << 216); redistribution |= bytes32((_demurrageModifierPpm & 0x0fffff) << 140);
redistribution |= bytes32((_value & 0xffffffffffffffffffffffff) << 56); redistribution |= bytes32((_participants & 0x0fffffffff) << 104);
redistribution |= bytes32(_period & 0xffffffffffffff); redistribution |= bytes32((_value & 0xffffffffffffffffff) << 32);
redistribution |= bytes32(_period & 0xffffffff);
return redistribution; return redistribution;
} }
// Serializes the demurrage period part of the redistribution word // Serializes the demurrage period part of the redistribution word
function toRedistributionPeriod(bytes32 redistribution) public pure returns (uint256) { function toRedistributionPeriod(bytes32 redistribution) public pure returns (uint256) {
return uint256(redistribution & 0x00000000000000000000000000000000000000000000000000ffffffffffffff); return uint256(redistribution) & 0xffffffff;
} }
// Serializes the supply part of the redistribution word // Serializes the supply part of the redistribution word
function toRedistributionSupply(bytes32 redistribution) public pure returns (uint256) { function toRedistributionSupply(bytes32 redistribution) public pure returns (uint256) {
return uint256(redistribution & 0x0000000000ffffffffffffffffffffffffffffffffffffffff00000000000000) >> 56; return uint256(redistribution & 0x00000000000000000000000000000000000000ffffffffffffffffff00000000) >> 32;
} }
// Serializes the number of participants part of the redistribution word // Serializes the number of participants part of the redistribution word
function toRedistributionParticipants(bytes32 redistribution) public pure returns (uint256) { function toRedistributionParticipants(bytes32 redistribution) public pure returns (uint256) {
return uint256(redistribution & 0x7fffffffff000000000000000000000000000000000000000000000000000000) >> 216; return uint256(redistribution & 0x00000000000000000000000000000fffffffff00000000000000000000000000) >> 104;
}
// Serializes the number of participants part of the redistribution word
function toRedistributionDemurrageModifier(bytes32 redistribution) public pure returns (uint256) {
return uint256(redistribution & 0x000000000000000000000000fffff00000000000000000000000000000000000) >> 140;
} }
// Client accessor to the redistributions array length // Client accessor to the redistributions array length
@ -163,16 +186,17 @@ contract RedistributedDemurrageToken {
// Add number of participants for the current redistribution period by one // Add number of participants for the current redistribution period by one
function incrementRedistributionParticipants() private returns (bool) { function incrementRedistributionParticipants() private returns (bool) {
uint256 currentRedistribution; bytes32 currentRedistribution;
uint256 tmpRedistribution;
uint256 participants; uint256 participants;
currentRedistribution = uint256(redistributions[redistributions.length-1]); currentRedistribution = redistributions[redistributions.length-1];
participants = ((currentRedistribution & 0x7fffffffff000000000000000000000000000000000000000000000000000000) >> 216) + 1; participants = toRedistributionParticipants(currentRedistribution) + 1;
currentRedistribution &= 0x8000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff; tmpRedistribution = uint256(currentRedistribution);
currentRedistribution |= participants << 216; tmpRedistribution &= 0xfffffffffffffffffffffffffffff000000000ffffffffffffffffffffffffff;
tmpRedistribution |= (participants & 0x0fffffffff) << 104;
//emit Debug(participants); redistributions[redistributions.length-1] = bytes32(tmpRedistribution);
redistributions[redistributions.length-1] = bytes32(currentRedistribution);
} }
// Save the current total supply amount to the current redistribution period // Save the current total supply amount to the current redistribution period
@ -180,8 +204,8 @@ contract RedistributedDemurrageToken {
uint256 currentRedistribution; uint256 currentRedistribution;
currentRedistribution = uint256(redistributions[redistributions.length-1]); currentRedistribution = uint256(redistributions[redistributions.length-1]);
currentRedistribution &= 0xffffffffff0000000000000000000000000000000000000000ffffffffffffff; currentRedistribution &= 0xffffffffffffffffffffffffffffffffffffff000000000000000000ffffffff;
currentRedistribution |= totalSupply << 56; currentRedistribution |= totalSupply << 32;
redistributions[redistributions.length-1] = bytes32(currentRedistribution); redistributions[redistributions.length-1] = bytes32(currentRedistribution);
} }
@ -206,13 +230,15 @@ contract RedistributedDemurrageToken {
// Deserialize the pemurrage period for the given account is participating in // Deserialize the pemurrage period for the given account is participating in
function accountPeriod(address _account) public view returns (uint256) { function accountPeriod(address _account) public view returns (uint256) {
return (uint256(account[_account]) & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000) >> 160; //return (uint256(account[_account]) & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000) >> 160;
return (uint256(account[_account]) & 0x00000000000000000000000000000000000000ffffffff000000000000000000) >> 72;
} }
// Save the given demurrage period as the currently participation period for the given address // Save the given demurrage period as the currently participation period for the given address
function registerAccountPeriod(address _account, uint256 _period) private returns (bool) { function registerAccountPeriod(address _account, uint256 _period) private returns (bool) {
account[_account] &= 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff; //account[_account] &= 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;
account[_account] |= bytes32(_period << 160); account[_account] &= 0xffffffffffffffffffffffffffffffffffffff00000000ffffffffffffffffff;
account[_account] |= bytes32(_period << 72);
incrementRedistributionParticipants(); incrementRedistributionParticipants();
} }
@ -248,8 +274,10 @@ contract RedistributedDemurrageToken {
if (truncatedResult < redistributionSupply) { if (truncatedResult < redistributionSupply) {
redistributionPeriod = toRedistributionPeriod(_redistribution); // since we reuse period here, can possibly be optimized by passing period instead redistributionPeriod = toRedistributionPeriod(_redistribution); // since we reuse period here, can possibly be optimized by passing period instead
redistributions[redistributionPeriod-1] &= 0x0000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff; // just to be safe, zero out all participant count data, in this case there will be only one //redistributions[redistributionPeriod-1] &= 0x0000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff; // just to be safe, zero out all participant count data, in this case there will be only one
redistributions[redistributionPeriod-1] |= 0x8000000001000000000000000000000000000000000000000000000000000000; redistributions[redistributionPeriod-1] &= 0xfffffffffffffffffffffffffffff000000000ffffffffffffffffffffffffff; // just to be safe, zero out all participant count data, in this case there will be only one
//redistributions[redistributionPeriod-1] |= 0x8000000001000000000000000000000000000000000000000000000000000000;
redistributions[redistributionPeriod-1] |= 0x8000000000000000000000000000000000000100000000000000000000000000;
} }
increaseBaseBalance(sinkAddress, unit / ppmDivider); //truncatedResult); increaseBaseBalance(sinkAddress, unit / ppmDivider); //truncatedResult);
@ -265,6 +293,7 @@ contract RedistributedDemurrageToken {
return false; return false;
} }
// is this needed?
redistributions[_period-1] |= 0x8000000000000000000000000000000000000000000000000000000000000000; redistributions[_period-1] |= 0x8000000000000000000000000000000000000000000000000000000000000000;
periodSupply = toRedistributionSupply(redistributions[_period-1]); periodSupply = toRedistributionSupply(redistributions[_period-1]);
@ -302,23 +331,39 @@ contract RedistributedDemurrageToken {
return true; return true;
} }
// Return timestamp of start of period threshold
function getPeriodTimeDelta(uint256 _periodCount) public view returns (uint256) {
return periodStart + (_periodCount * periodDuration);
}
// Amount of demurrage cycles inbetween the current timestamp and the given target time
function demurrageCycles(uint256 _target) public view returns (uint256) {
return (block.timestamp - _target) / 60;
}
// Recalculate the demurrage modifier for the new period // Recalculate the demurrage modifier for the new period
// After this, all REPORTED balances will have been reduced by the corresponding ratio (but the effecive totalsupply stays the same) // After this, all REPORTED balances will have been reduced by the corresponding ratio (but the effecive totalsupply stays the same)
//function applyTax() public returns (uint256) { //function applyTax() public returns (uint256) {
function changePeriod() public returns (uint256) { function changePeriod() public returns (bool) {
bytes32 currentRedistribution; bytes32 currentRedistribution;
bytes32 nextRedistribution; bytes32 nextRedistribution;
uint256 currentPeriod; uint256 currentPeriod;
uint256 currentParticipants; uint256 currentParticipants;
uint256 currentRemainder; uint256 currentRemainder;
uint256 currentRedistributionDemurrage;
uint256 demurrageCounts;
uint256 periodTimestamp;
currentRedistribution = checkPeriod(); currentRedistribution = checkPeriod();
if (currentRedistribution == bytes32(0x00)) { if (currentRedistribution == bytes32(0x00)) {
return demurrageModifier; return false;
} }
//demurrageModifier -= (demurrageModifier * taxLevel) / 1000000; periodTimestamp = getPeriodTimeDelta(currentPeriod);
demurrageCounts = demurrageCycles(periodTimestamp);
currentRedistributionDemurrage = toRedistributionDemurrageModifier(currentRedistribution);
currentPeriod = toRedistributionPeriod(currentRedistribution); currentPeriod = toRedistributionPeriod(currentRedistribution);
nextRedistribution = toRedistribution(0, totalSupply, currentPeriod + 1); nextRedistribution = toRedistribution(0, toTaxPeriodAmount(currentRedistributionDemurrage, demurrageCounts), totalSupply, currentPeriod + 1);
redistributions.push(nextRedistribution); redistributions.push(nextRedistribution);
currentParticipants = toRedistributionParticipants(currentRedistribution); currentParticipants = toRedistributionParticipants(currentRedistribution);
@ -328,10 +373,11 @@ contract RedistributedDemurrageToken {
currentRemainder = remainder(currentParticipants, totalSupply); // we can use totalSupply directly because it will always be the same as the recorded supply on the current redistribution currentRemainder = remainder(currentParticipants, totalSupply); // we can use totalSupply directly because it will always be the same as the recorded supply on the current redistribution
applyRemainderOnPeriod(currentRemainder, currentPeriod); applyRemainderOnPeriod(currentRemainder, currentPeriod);
} }
return demurrageModifier; return true;
} }
// Calculate a value reduced by demurrage by the given period // Calculate a value reduced by demurrage by the given period
// TODO: higher precision
function toTaxPeriodAmount(uint256 _value, uint256 _period) public view returns (uint256) { function toTaxPeriodAmount(uint256 _value, uint256 _period) public view returns (uint256) {
uint256 valueFactor; uint256 valueFactor;
uint256 truncatedTaxLevel; uint256 truncatedTaxLevel;
@ -370,7 +416,8 @@ contract RedistributedDemurrageToken {
baseValue = ((supply / participants) * (taxLevel / 1000000)) / ppmDivider; baseValue = ((supply / participants) * (taxLevel / 1000000)) / ppmDivider;
value = toTaxPeriodAmount(baseValue, period - 1); value = toTaxPeriodAmount(baseValue, period - 1);
account[_account] &= bytes32(0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff); //account[_account] &= bytes32(0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff);
account[_account] &= bytes32(0xffffffffffffffffffffffffffffffffffffff00000000ffffffffffffffffff);
increaseBaseBalance(_account, value); increaseBaseBalance(_account, value);
emit Redistribution(_account, period, value); emit Redistribution(_account, period, value);