From 4e9861b6385731d18ab0b347230a69f57fc50d73 Mon Sep 17 00:00:00 2001 From: Guillaume Date: Wed, 11 Jul 2018 23:06:09 +0200 Subject: [PATCH 1/7] Add removeProvider method --- contracts/ProviderPool.sol | 4 ++++ contracts/TestProviderPool.sol | 13 +++++++++---- 2 files changed, 13 insertions(+), 4 deletions(-) diff --git a/contracts/ProviderPool.sol b/contracts/ProviderPool.sol index b597a62..c04dd00 100644 --- a/contracts/ProviderPool.sol +++ b/contracts/ProviderPool.sol @@ -29,4 +29,8 @@ contract ProviderPool is Ownable { function updateProvider(address _provider, uint _newBondedAmount) internal { providerPool.updateKey(_provider, _newBondedAmount, 0, 0); } + + function removeProvider(address _provider) internal { + providerPool.remove(_provider); + } } diff --git a/contracts/TestProviderPool.sol b/contracts/TestProviderPool.sol index 877769a..54d7539 100644 --- a/contracts/TestProviderPool.sol +++ b/contracts/TestProviderPool.sol @@ -5,13 +5,18 @@ import "../contracts/ProviderPool.sol"; contract TestProviderPool is ProviderPool { // @dev convenience method to be able to call addProvider from web3js (it has internal visibility) - function publicAddProvider(address _providerAddress, uint _bondedAmount) public { - addProvider(_providerAddress, _bondedAmount); + function publicAddProvider(address _provider, uint _bondedAmount) public { + addProvider(_provider, _bondedAmount); } // @dev convenience method to be able to call updateProvider from web3js (it has internal visibility) - function publicUpdateProvider(address _providerAddress, uint _bondedAmount) public { - updateProvider(_providerAddress, _bondedAmount); + function publicUpdateProvider(address _provider, uint _bondedAmount) public { + updateProvider(_provider, _bondedAmount); + } + + // @dev convenience method to be able to call removeProvider from web3js (it has internal visibility) + function publicRemoveProvider(address _provider) public { + removeProvider(_provider); } } From 158a4c2d37e9e2221ac03bba89097611065e0d82 Mon Sep 17 00:00:00 2001 From: Guillaume Date: Thu, 12 Jul 2018 00:03:03 +0200 Subject: [PATCH 2/7] Fix assertProvidersAreSortedByBondedAmount --- test/TestProviderPool.spec.js | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/test/TestProviderPool.spec.js b/test/TestProviderPool.spec.js index ae4fa7b..690d305 100644 --- a/test/TestProviderPool.spec.js +++ b/test/TestProviderPool.spec.js @@ -17,7 +17,7 @@ contract('ProviderPool', accounts => { let currentAddress = providerPool[0]; // [0] is head of the list let node = await pp.getProvider.call(currentAddress); let end = providerPool[1]; // [1] is tail of the list - do { + while(currentAddress != end) { assert(bondedAmountOfPreviousAddress >= node[0]); // [0] is the bondedAmount assert.equal(node[2], previousAddress); // [2] is previous address in the list bondedAmountOfPreviousAddress = node[0].toNumber(); @@ -25,7 +25,6 @@ contract('ProviderPool', accounts => { currentAddress = node[1]; // [1] is next address in the list node = await pp.getProvider.call(currentAddress); } - while(currentAddress != end) } describe('setMaxNumberOfProviders', () => { From 85a538748b4e07c5b5879b26e9844029261c80fd Mon Sep 17 00:00:00 2001 From: Guillaume Date: Thu, 12 Jul 2018 00:03:18 +0200 Subject: [PATCH 3/7] Add tests for removeProvider --- test/TestProviderPool.spec.js | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/test/TestProviderPool.spec.js b/test/TestProviderPool.spec.js index 690d305..e7e1337 100644 --- a/test/TestProviderPool.spec.js +++ b/test/TestProviderPool.spec.js @@ -153,5 +153,35 @@ contract('ProviderPool', accounts => { await assertFail( pp.publicUpdateProvider(accounts[5], 1) ); }); }); + + describe('removeProvider', () => { + + it('should remove the provider from the pool', async () => { + assert.equal(true, await pp.containsProvider(accounts[0])); + await pp.publicRemoveProvider(accounts[0]); + assert.equal(false, await pp.containsProvider(accounts[0])); + }); + + it('should decrease the size of the pool by one', async () => { + let providerPool = await pp.providerPool.call(); + const previousSize = providerPool[3].toNumber(); // [3] is the current size of the pool + await pp.publicRemoveProvider(accounts[1]); + providerPool = await pp.providerPool.call(); + assert.equal(previousSize - 1, providerPool[3]); + }); + + it('should keep the list in decreasing order of bonded amounts', async () => { + await assertProvidersAreSortedByBondedAmount(); + await pp.publicRemoveProvider(accounts[3]); + await assertProvidersAreSortedByBondedAmount(); + await pp.publicRemoveProvider(accounts[4]); + await assertProvidersAreSortedByBondedAmount(); + }); + + it('should fail if provider is not in the pool', async () => { + assert.equal(false, await pp.containsProvider(accounts[0])); + await assertFail( pp.publicRemoveProvider(accounts[0]) ); + }); + }); }); From 0cf6c04f36038179165868199dfcb6a78ae75f0e Mon Sep 17 00:00:00 2001 From: Guillaume Date: Thu, 12 Jul 2018 00:27:32 +0200 Subject: [PATCH 4/7] Link resignAsProvider to removeProvider --- contracts/ProviderRound.sol | 1 + 1 file changed, 1 insertion(+) diff --git a/contracts/ProviderRound.sol b/contracts/ProviderRound.sol index dc48cb1..dd98c73 100644 --- a/contracts/ProviderRound.sol +++ b/contracts/ProviderRound.sol @@ -75,6 +75,7 @@ contract ProviderRound is TransmuteToken, RoundManager, ProviderPool { function resignAsProvider() public { require(providers[msg.sender].status != ProviderStatus.Unregistered); + removeProvider(msg.sender); delete providers[msg.sender]; emit ProviderResigned(msg.sender); } From 145212051f292d35ef4a88913f2c920928fb4116 Mon Sep 17 00:00:00 2001 From: Guillaume Date: Thu, 12 Jul 2018 00:27:39 +0200 Subject: [PATCH 5/7] Add test --- test/TestProviderRound.spec.js | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/test/TestProviderRound.spec.js b/test/TestProviderRound.spec.js index 976737e..56bc3bf 100644 --- a/test/TestProviderRound.spec.js +++ b/test/TestProviderRound.spec.js @@ -170,9 +170,10 @@ contract('ProviderRound', accounts => { await providerRound.initializeRound(); await approveBondProvider(22, 10, 1, 25, 1, accounts[0]); await approveBondProvider(22, 10, 1, 25, 1, accounts[1]); + await approveBondProvider(22, 10, 1, 25, 1, accounts[2]); }); - it('should remove a provider from the provider mapping', async () => { + it('should remove the provider from the provider mapping', async () => { const registeredProvider = await providerRound.providers.call(accounts[0]); assert.equal(PROVIDER_REGISTERED, registeredProvider[0]); // [0] is providerStatus await providerRound.resignAsProvider({from: accounts[0]}); @@ -185,18 +186,24 @@ contract('ProviderRound', accounts => { assert.equal(0, resignedProvider[5]); // [5] is totalAmountBonded }); + it('should remove the provider from the providerPool', async () => { + assert.equal(true, await providerRound.containsProvider(accounts[1])); + await providerRound.resignAsProvider({from: accounts[1]}); + assert.equal(false, await providerRound.containsProvider(accounts[1])); + }); + it('should send a ProviderResigned event', async () => { - const result = await providerRound.resignAsProvider({from: accounts[1]}); + const result = await providerRound.resignAsProvider({from: accounts[2]}); assert.web3Event(result, { event: 'ProviderResigned', args: { - _providerAddress: accounts[1], + _providerAddress: accounts[2], } }); }); it("should fail if the transaction's sender is not a provider", async () => { - await assertFail( providerRound.resignAsProvider({from: accounts[2]}) ); + await assertFail( providerRound.resignAsProvider({from: accounts[3]}) ); }); }); From 8781188308dfe8b7418775451f5bd864d123332e Mon Sep 17 00:00:00 2001 From: Guillaume Date: Thu, 12 Jul 2018 00:31:53 +0200 Subject: [PATCH 6/7] Rename contract --- .../{ProviderRound.sol => TransmuteDPOS.sol} | 3 +- migrations/2_deploy_contracts.js | 6 +- ...ound.spec.js => TestTransmuteDPOS.spec.js} | 162 +++++++++--------- 3 files changed, 85 insertions(+), 86 deletions(-) rename contracts/{ProviderRound.sol => TransmuteDPOS.sol} (96%) rename test/{TestProviderRound.spec.js => TestTransmuteDPOS.spec.js} (55%) diff --git a/contracts/ProviderRound.sol b/contracts/TransmuteDPOS.sol similarity index 96% rename from contracts/ProviderRound.sol rename to contracts/TransmuteDPOS.sol index dd98c73..65bb120 100644 --- a/contracts/ProviderRound.sol +++ b/contracts/TransmuteDPOS.sol @@ -4,8 +4,7 @@ import "./TransmuteToken.sol"; import "./RoundManager.sol"; import "./ProviderPool.sol"; -// TODO: Change name to TransmuteDPOS -contract ProviderRound is TransmuteToken, RoundManager, ProviderPool { +contract TransmuteDPOS is TransmuteToken, RoundManager, ProviderPool { event ProviderAdded ( address indexed _providerAddress, diff --git a/migrations/2_deploy_contracts.js b/migrations/2_deploy_contracts.js index c28f5e3..2a1d4df 100644 --- a/migrations/2_deploy_contracts.js +++ b/migrations/2_deploy_contracts.js @@ -1,5 +1,5 @@ const TST = artifacts.require('./TransmuteToken.sol'); -const ProviderRound = artifacts.require('./ProviderRound.sol'); +const TransmuteDPOS = artifacts.require('./TransmuteDPOS.sol'); const RoundManager = artifacts.require('./RoundManager.sol'); const SortedDoublyLL = artifacts.require('./SortedDoublyLL.sol'); const TestProviderPool = artifacts.require('./TestProviderPool.sol'); @@ -7,8 +7,8 @@ const TestProviderPool = artifacts.require('./TestProviderPool.sol'); module.exports = deployer => { deployer.deploy(TST); deployer.deploy(SortedDoublyLL); - deployer.link(SortedDoublyLL, ProviderRound); - deployer.deploy(ProviderRound); + deployer.link(SortedDoublyLL, TransmuteDPOS); + deployer.deploy(TransmuteDPOS); deployer.deploy(RoundManager); deployer.link(SortedDoublyLL, TestProviderPool); deployer.deploy(TestProviderPool); diff --git a/test/TestProviderRound.spec.js b/test/TestTransmuteDPOS.spec.js similarity index 55% rename from test/TestProviderRound.spec.js rename to test/TestTransmuteDPOS.spec.js index 56bc3bf..b6867aa 100644 --- a/test/TestProviderRound.spec.js +++ b/test/TestTransmuteDPOS.spec.js @@ -1,10 +1,10 @@ -const ProviderRound = artifacts.require('./ProviderRound.sol'); +const TransmuteDPOS = artifacts.require('./TransmuteDPOS.sol'); const { blockMiner, assertFail } = require('./utils.js'); require('truffle-test-utils').init(); -contract('ProviderRound', accounts => { +contract('TransmuteDPOS', accounts => { - let providerRound; + let tdpos; let contractAddress; const PROVIDER_POOL_SIZE = 5; const PROVIDER_UNREGISTERED = 0; @@ -16,40 +16,40 @@ contract('ProviderRound', accounts => { // Step 3: Registering parameters with provider() async function approveBondProvider(pricePerStorageMineral, pricePerComputeMineral, blockRewardCut, feeShare, amountBonded, providerAddress) { // This approve function comes from the ERC20 Transmute Token contract - await providerRound.approve(contractAddress, amountBonded, {from: providerAddress}); - await providerRound.bond(providerAddress, amountBonded, {from: providerAddress}); - await providerRound.provider(pricePerStorageMineral, pricePerComputeMineral, blockRewardCut, feeShare, {from: providerAddress}); + await tdpos.approve(contractAddress, amountBonded, {from: providerAddress}); + await tdpos.bond(providerAddress, amountBonded, {from: providerAddress}); + await tdpos.provider(pricePerStorageMineral, pricePerComputeMineral, blockRewardCut, feeShare, {from: providerAddress}); } describe('provider', () => { before(async () => { - providerRound = await ProviderRound.deployed(); - contractAddress = providerRound.address; + tdpos = await TransmuteDPOS.deployed(); + contractAddress = tdpos.address; for(let i = 0; i < 5; i++) { - await providerRound.mint(accounts[i], 1000, {from: accounts[0]}); + await tdpos.mint(accounts[i], 1000, {from: accounts[0]}); } - await providerRound.setMaxNumberOfProviders(PROVIDER_POOL_SIZE); + await tdpos.setMaxNumberOfProviders(PROVIDER_POOL_SIZE); }); beforeEach(async () => { - await blockMiner.mineUntilEndOfElectionPeriod(providerRound); - await providerRound.initializeRound(); + await blockMiner.mineUntilEndOfElectionPeriod(tdpos); + await tdpos.initializeRound(); }); it('should fail if the provider does not bond some tokens on himself first', async () => { - await assertFail( providerRound.provider(22, 10, 1, 25, {from: accounts[0]}) ); + await assertFail( tdpos.provider(22, 10, 1, 25, {from: accounts[0]}) ); }); it('should initially set totalBondedAmount to the amount the provider bonded to himself', async () => { await approveBondProvider(22, 10, 1, 25, 42, accounts[0]); - const provider = await providerRound.providers.call(accounts[0]); + const provider = await tdpos.providers.call(accounts[0]); assert.equal(42, provider[5]); // [5] is totalBondedAmount }); it("should register a provider's parameters", async () => { await approveBondProvider(10, 20, 2, 35, 1, accounts[1]); - const provider = await providerRound.providers.call(accounts[1]); + const provider = await tdpos.providers.call(accounts[1]); assert.equal(provider[0], PROVIDER_REGISTERED); // [0] is providerStatus assert.equal(provider[1].toNumber(), 10); // [1] is pricePerStorageMineral assert.equal(provider[2].toNumber(), 20); // [2] is pricePerComputeMineral @@ -63,32 +63,32 @@ contract('ProviderRound', accounts => { 'provider should not be able to have a negative blockRewardCut' ); await assertFail( - providerRound.provider(22, 10, 1, 125, {from: accounts[2]}), + tdpos.provider(22, 10, 1, 125, {from: accounts[2]}), 'provider should not be able to have more than 100% feeShare' ); }); it('should fail if not called during an active round', async () => { - await blockMiner.mineUntilEndOfElectionPeriod(providerRound); - await assertFail( providerRound.provider(22, 10, 1, 25, {from: accounts[0]}) ); + await blockMiner.mineUntilEndOfElectionPeriod(tdpos); + await assertFail( tdpos.provider(22, 10, 1, 25, {from: accounts[0]}) ); }); it('should work if called before the lock period of an active round', async () => { - await blockMiner.mineUntilLastBlockBeforeLockPeriod(providerRound); - await providerRound.provider(23, 10, 1, 25, {from: accounts[0]}); - const provider = await providerRound.providers(accounts[0]); + await blockMiner.mineUntilLastBlockBeforeLockPeriod(tdpos); + await tdpos.provider(23, 10, 1, 25, {from: accounts[0]}); + const provider = await tdpos.providers(accounts[0]); assert.equal(23, provider[1]); // [1] is pricePerStorageMineral }); it('should fail during the lock period of an active round', async () => { - await blockMiner.mineUntilLastBlockBeforeLockPeriod(providerRound); + await blockMiner.mineUntilLastBlockBeforeLockPeriod(tdpos); // Enter lock period await blockMiner.mine(1); - await assertFail( providerRound.provider(22, 10, 1, 25, {from: accounts[0]}) ); + await assertFail( tdpos.provider(22, 10, 1, 25, {from: accounts[0]}) ); }); it('should send a ProviderAdded event for a new provider', async () => { - const result = await providerRound.provider(22, 10, 1, 25, {from: accounts[2]}); + const result = await tdpos.provider(22, 10, 1, 25, {from: accounts[2]}); assert.web3Event(result, { event: 'ProviderAdded', args: { @@ -102,7 +102,7 @@ contract('ProviderRound', accounts => { }); it('should send a ProviderUpdated event for an existing provider', async () => { - const result = await providerRound.provider(21, 11, 2, 24, {from: accounts[2]}); + const result = await tdpos.provider(21, 11, 2, 24, {from: accounts[2]}); assert.web3Event(result, { event: 'ProviderUpdated', args: { @@ -118,24 +118,24 @@ contract('ProviderRound', accounts => { // TODO: Doc about providers, pool and active pool it('should add the provider to the pool if he is Unregistered and size < maxSize', async () => { // Check that provider isn't registered yet - assert.equal(false, await providerRound.containsProvider(accounts[3])); + assert.equal(false, await tdpos.containsProvider(accounts[3])); // Check the size of the pool increases by 1 - let providerPool = await providerRound.providerPool.call(); + let providerPool = await tdpos.providerPool.call(); const previousSize = providerPool[3].toNumber(); // [3] is current size of the pool await approveBondProvider(21, 13, 3, 26, 1, accounts[3]); - providerPool = await providerRound.providerPool.call(); + providerPool = await tdpos.providerPool.call(); assert.equal(previousSize + 1, providerPool[3]); // Check that the provider is registered in the pool now - assert.equal(true, await providerRound.containsProvider(accounts[3])); + assert.equal(true, await tdpos.containsProvider(accounts[3])); }); it('should fail if provider is Unregistered and size == maxSize', async () => { - let providerPool = await providerRound.providerPool.call(); + let providerPool = await tdpos.providerPool.call(); const maxSize = providerPool[2].toNumber(); // [2] is maxSize let currentSize = providerPool[3]; // [3] is current size assert.isAbove(maxSize, currentSize.toNumber()); await approveBondProvider(20 ,10, 2, 25, 1, accounts[4]); - providerPool = await providerRound.providerPool.call(); + providerPool = await tdpos.providerPool.call(); currentSize = providerPool[3]; assert.equal(maxSize, currentSize); await assertFail( approveBondProvider(20 ,10, 2, 25, 1, accounts[5]) ); @@ -143,41 +143,41 @@ contract('ProviderRound', accounts => { it('should update the value of totalBondedAmount in the providerPool if the provider is Registered and size < maxSize', async () => { // Check that provider is Registered - assert.equal(true, await providerRound.containsProvider(accounts[3])); + assert.equal(true, await tdpos.containsProvider(accounts[3])); // Check the size of the pool stays the same - let providerPool = await providerRound.providerPool.call(); + let providerPool = await tdpos.providerPool.call(); const previousSize = providerPool[3]; // [3] is current size of the pool - await providerRound.provider(19, 10, 2, 20, {from: accounts[3]}); - providerPool = await providerRound.providerPool.call(); + await tdpos.provider(19, 10, 2, 20, {from: accounts[3]}); + providerPool = await tdpos.providerPool.call(); assert.deepEqual(previousSize, providerPool[3]); }); it('should work if provider is Registered and size == maxSize', async () => { - await providerRound.provider(21 ,10, 2, 25, {from: accounts[4]}); + await tdpos.provider(21 ,10, 2, 25, {from: accounts[4]}); }); }); describe('resignAsProvider', () => { before(async () => { - providerRound = await ProviderRound.new(); - contractAddress = providerRound.address; + tdpos = await TransmuteDPOS.new(); + contractAddress = tdpos.address; for(let i = 0; i < 5; i++) { - await providerRound.mint(accounts[i], 1000, {from: accounts[0]}); + await tdpos.mint(accounts[i], 1000, {from: accounts[0]}); } - await providerRound.setMaxNumberOfProviders(PROVIDER_POOL_SIZE); - await blockMiner.mineUntilEndOfElectionPeriod(providerRound); - await providerRound.initializeRound(); + await tdpos.setMaxNumberOfProviders(PROVIDER_POOL_SIZE); + await blockMiner.mineUntilEndOfElectionPeriod(tdpos); + await tdpos.initializeRound(); await approveBondProvider(22, 10, 1, 25, 1, accounts[0]); await approveBondProvider(22, 10, 1, 25, 1, accounts[1]); await approveBondProvider(22, 10, 1, 25, 1, accounts[2]); }); it('should remove the provider from the provider mapping', async () => { - const registeredProvider = await providerRound.providers.call(accounts[0]); + const registeredProvider = await tdpos.providers.call(accounts[0]); assert.equal(PROVIDER_REGISTERED, registeredProvider[0]); // [0] is providerStatus - await providerRound.resignAsProvider({from: accounts[0]}); - const resignedProvider = await providerRound.providers.call(accounts[0]); + await tdpos.resignAsProvider({from: accounts[0]}); + const resignedProvider = await tdpos.providers.call(accounts[0]); assert.equal(PROVIDER_UNREGISTERED, resignedProvider[0]); // [0] is providerStatus assert.equal(0, resignedProvider[1]); // [1] is pricePerStorageMineral assert.equal(0, resignedProvider[2]); // [2] is pricePerComputeMineral @@ -187,13 +187,13 @@ contract('ProviderRound', accounts => { }); it('should remove the provider from the providerPool', async () => { - assert.equal(true, await providerRound.containsProvider(accounts[1])); - await providerRound.resignAsProvider({from: accounts[1]}); - assert.equal(false, await providerRound.containsProvider(accounts[1])); + assert.equal(true, await tdpos.containsProvider(accounts[1])); + await tdpos.resignAsProvider({from: accounts[1]}); + assert.equal(false, await tdpos.containsProvider(accounts[1])); }); it('should send a ProviderResigned event', async () => { - const result = await providerRound.resignAsProvider({from: accounts[2]}); + const result = await tdpos.resignAsProvider({from: accounts[2]}); assert.web3Event(result, { event: 'ProviderResigned', args: { @@ -203,75 +203,75 @@ contract('ProviderRound', accounts => { }); it("should fail if the transaction's sender is not a provider", async () => { - await assertFail( providerRound.resignAsProvider({from: accounts[3]}) ); + await assertFail( tdpos.resignAsProvider({from: accounts[3]}) ); }); }); describe('bond', () => { before(async () => { - providerRound = await ProviderRound.new(); - contractAddress = providerRound.address; + tdpos = await TransmuteDPOS.new(); + contractAddress = tdpos.address; for(let i = 0; i < 10; i++) { - await providerRound.mint(accounts[i], 1000, {from: accounts[0]}); + await tdpos.mint(accounts[i], 1000, {from: accounts[0]}); } - await providerRound.setMaxNumberOfProviders(PROVIDER_POOL_SIZE); - await blockMiner.mineUntilEndOfElectionPeriod(providerRound); - await providerRound.initializeRound(); + await tdpos.setMaxNumberOfProviders(PROVIDER_POOL_SIZE); + await blockMiner.mineUntilEndOfElectionPeriod(tdpos); + await tdpos.initializeRound(); await approveBondProvider(22, 10, 1, 25, 1, accounts[0]); await approveBondProvider(10, 20, 2, 35, 1, accounts[1]); }); it('should fail if the delegator does not approve to transfer at least the bonded amount', async () => { - await assertFail( providerRound.bond(accounts[0], 10, {from: accounts[5]}) ); - await providerRound.approve(contractAddress, 9, {from: accounts[5]}); - await assertFail( providerRound.bond(accounts[0], 10, {from: accounts[5]}) ); + await assertFail( tdpos.bond(accounts[0], 10, {from: accounts[5]}) ); + await tdpos.approve(contractAddress, 9, {from: accounts[5]}); + await assertFail( tdpos.bond(accounts[0], 10, {from: accounts[5]}) ); }); it('should add a delegator to the delegators list', async () => { - await providerRound.approve(contractAddress, 10, {from: accounts[5]}); - await providerRound.bond(accounts[0], 10, {from: accounts[5]}); - const firstDelegator = await providerRound.delegators.call(accounts[5]); + await tdpos.approve(contractAddress, 10, {from: accounts[5]}); + await tdpos.bond(accounts[0], 10, {from: accounts[5]}); + const firstDelegator = await tdpos.delegators.call(accounts[5]); assert.equal(accounts[0], firstDelegator[0]); // [0] is delegateAddress assert.equal(10, firstDelegator[1]); // [1] is amountBonded }); it('should increase the totalAmountBonded of the provider', async () => { - await providerRound.approve(contractAddress, 20, {from: accounts[6]}); - await providerRound.bond(accounts[0], 20, {from: accounts[6]}); - const provider = await providerRound.providers.call(accounts[0]); + await tdpos.approve(contractAddress, 20, {from: accounts[6]}); + await tdpos.bond(accounts[0], 20, {from: accounts[6]}); + const provider = await tdpos.providers.call(accounts[0]); assert.equal(31, provider[5].toNumber()); // [5] is totalAmountBonded }); it('should fail if the address is not a registered provider address', async () => { - await providerRound.approve(contractAddress, 15, {from: accounts[7]}) - await assertFail( providerRound.bond(accounts[2], 15, {from: accounts[7]}) ); + await tdpos.approve(contractAddress, 15, {from: accounts[7]}) + await assertFail( tdpos.bond(accounts[2], 15, {from: accounts[7]}) ); }); it('should work if the address is not a registered provider address but the address is the sender address', async () => { - await providerRound.approve(contractAddress, 15, {from: accounts[3]}) - await providerRound.bond(accounts[3], 15, {from: accounts[3]}); + await tdpos.approve(contractAddress, 15, {from: accounts[3]}) + await tdpos.bond(accounts[3], 15, {from: accounts[3]}); }); it('should fail if called twice by the same delegator', async () => { - await providerRound.approve(contractAddress, 40, {from: accounts[8]}); - await providerRound.bond(accounts[1], 20, {from: accounts[8]}); - await assertFail( providerRound.bond(accounts[1], 20, {from: accounts[8]}) ); + await tdpos.approve(contractAddress, 40, {from: accounts[8]}); + await tdpos.bond(accounts[1], 20, {from: accounts[8]}); + await assertFail( tdpos.bond(accounts[1], 20, {from: accounts[8]}) ); }); it('should fail if TST balance is less than bonded amount', async () => { - await providerRound.approve(contractAddress, 1001, {from: accounts[9]}); - await assertFail( providerRound.bond(accounts[1], 1001, {from: accounts[9]}) ) - assert(1001 >= (await providerRound.providers(accounts[1]))[5]); + await tdpos.approve(contractAddress, 1001, {from: accounts[9]}); + await assertFail( tdpos.bond(accounts[1], 1001, {from: accounts[9]}) ) + assert(1001 >= (await tdpos.providers(accounts[1]))[5]); }); it("should transfer amount from the delegator's balance to the contract's balance", async () => { - const contractBalance = (await providerRound.balanceOf(providerRound.address)).toNumber(); - assert.equal(1000, await providerRound.balanceOf(accounts[9])); - await providerRound.approve(contractAddress, 300, {from: accounts[9]}); - await providerRound.bond(accounts[1], 300, {from: accounts[9]}); - assert.equal(700, await providerRound.balanceOf(accounts[9])); - assert.equal(contractBalance + 300, await providerRound.balanceOf(providerRound.address)); + const contractBalance = (await tdpos.balanceOf(tdpos.address)).toNumber(); + assert.equal(1000, await tdpos.balanceOf(accounts[9])); + await tdpos.approve(contractAddress, 300, {from: accounts[9]}); + await tdpos.bond(accounts[1], 300, {from: accounts[9]}); + assert.equal(700, await tdpos.balanceOf(accounts[9])); + assert.equal(contractBalance + 300, await tdpos.balanceOf(tdpos.address)); }); }); }); From de6cb0f082c5c784b82c5271fbcd44f4462dc464 Mon Sep 17 00:00:00 2001 From: Guillaume Date: Thu, 12 Jul 2018 00:40:46 +0200 Subject: [PATCH 7/7] Fix warnings --- contracts/RoundManager.sol | 2 +- contracts/TransmuteDPOS.sol | 30 +++++++++++++++--------------- test/TestTransmuteDPOS.spec.js | 1 - 3 files changed, 16 insertions(+), 17 deletions(-) diff --git a/contracts/RoundManager.sol b/contracts/RoundManager.sol index f1d623e..bf20255 100644 --- a/contracts/RoundManager.sol +++ b/contracts/RoundManager.sol @@ -18,7 +18,7 @@ contract RoundManager { _; } - constructor() { + constructor() public { electionPeriodLength = 20; rateLockDeadline = 5; } diff --git a/contracts/TransmuteDPOS.sol b/contracts/TransmuteDPOS.sol index 65bb120..5d9dd31 100644 --- a/contracts/TransmuteDPOS.sol +++ b/contracts/TransmuteDPOS.sol @@ -53,23 +53,23 @@ contract TransmuteDPOS is TransmuteToken, RoundManager, ProviderPool { { require(_blockRewardCut <= 100); require(_feeShare <= 100); - Provider storage provider = providers[msg.sender]; - Delegator storage delegator = delegators[msg.sender]; - require(delegator.delegateAddress == msg.sender); - require(delegator.amountBonded > 0); - if (provider.status == ProviderStatus.Unregistered) { + Provider storage p = providers[msg.sender]; + Delegator storage d = delegators[msg.sender]; + require(d.delegateAddress == msg.sender); + require(d.amountBonded > 0); + if (p.status == ProviderStatus.Unregistered) { numberOfProviders = numberOfProviders.add(1); - addProvider(msg.sender, provider.totalAmountBonded); + addProvider(msg.sender, p.totalAmountBonded); emit ProviderAdded(msg.sender, _pricePerStorageMineral, _pricePerComputeMineral, _blockRewardCut, _feeShare); } else { - updateProvider(msg.sender, provider.totalAmountBonded); + updateProvider(msg.sender, p.totalAmountBonded); emit ProviderUpdated(msg.sender, _pricePerStorageMineral, _pricePerComputeMineral, _blockRewardCut, _feeShare); } - provider.status = ProviderStatus.Registered; - provider.pricePerStorageMineral = _pricePerStorageMineral; - provider.pricePerComputeMineral = _pricePerComputeMineral; - provider.blockRewardCut = _blockRewardCut; - provider.feeShare = _feeShare; + p.status = ProviderStatus.Registered; + p.pricePerStorageMineral = _pricePerStorageMineral; + p.pricePerComputeMineral = _pricePerComputeMineral; + p.blockRewardCut = _blockRewardCut; + p.feeShare = _feeShare; } function resignAsProvider() public { @@ -80,14 +80,14 @@ contract TransmuteDPOS is TransmuteToken, RoundManager, ProviderPool { } function bond(address _providerAddress, uint _amount) external { - Provider storage provider = providers[_providerAddress]; + Provider storage p = providers[_providerAddress]; // A delegator is only allowed to bond to an Unregistered provider if the provider is himself // otherwise _providerAddress has to be associated with a Registered provider - require(_providerAddress == msg.sender || provider.status != ProviderStatus.Unregistered); + require(_providerAddress == msg.sender || p.status != ProviderStatus.Unregistered); // Check if delegator has not already bonded to some address require(delegators[msg.sender].delegateAddress == address(0)); this.transferFrom(msg.sender, this, _amount); delegators[msg.sender] = Delegator(_providerAddress, _amount); - provider.totalAmountBonded = provider.totalAmountBonded.add(_amount); + p.totalAmountBonded = p.totalAmountBonded.add(_amount); } } diff --git a/test/TestTransmuteDPOS.spec.js b/test/TestTransmuteDPOS.spec.js index b6867aa..b886be5 100644 --- a/test/TestTransmuteDPOS.spec.js +++ b/test/TestTransmuteDPOS.spec.js @@ -115,7 +115,6 @@ contract('TransmuteDPOS', accounts => { }); }); - // TODO: Doc about providers, pool and active pool it('should add the provider to the pool if he is Unregistered and size < maxSize', async () => { // Check that provider isn't registered yet assert.equal(false, await tdpos.containsProvider(accounts[3]));