[eth-contracts] ServiceProviderFactory init fix + Coverage

eth-contracts/contracts/DelegateManager.sol

@@ -531,7 +531,7 @@ contract DelegateManager is InitializableV2 {
     }
 
     function setStakingAddress(address _address) external {
-        require(msg.sender == governanceAddress, "Only callable by self");
+        require(msg.sender == governanceAddress, "Only governance");
         stakingAddress = _address;
     }
 

eth-contracts/contracts/ServiceProviderFactory.sol

@@ -112,15 +112,8 @@ contract ServiceProviderFactory is InitializableV2 {
       uint spId
     );
 
-    function initialize (
-        address _registryAddress,
-        address _governanceAddress
-    ) public initializer
+    function initialize (address _governanceAddress) public initializer
     {
-        require(
-            _registryAddress != address(0x00),
-            "Requires non-zero _registryAddress"
-        );
         governanceAddress = _governanceAddress;
 
         // Configure direct minimum stake for deployer

eth-contracts/migrations/7_versioning_service_migration.js

@@ -103,8 +103,8 @@ module.exports = (deployer, network, accounts) => {
     const serviceProviderFactory0 = await deployer.deploy(ServiceProviderFactory, { from: proxyDeployerAddress })
     const serviceProviderFactoryCalldata = _lib.encodeCall(
       'initialize',
-      ['address', 'address'],
-      [registryAddress, process.env.governanceAddress]
+      ['address'],
+      [process.env.governanceAddress]
     )
     const serviceProviderFactoryProxy = await deployer.deploy(
       AudiusAdminUpgradeabilityProxy,

eth-contracts/test/delegateManager.test.js

@@ -108,8 +108,8 @@ contract('DelegateManager', async (accounts) => {
     let serviceProviderFactory0 = await ServiceProviderFactory.new({ from: proxyDeployerAddress })
     const serviceProviderFactoryCalldata = _lib.encodeCall(
       'initialize',
-      ['address', 'address'],
-      [registry.address, governance.address]
+      ['address'],
+      [governance.address]
     )
     let serviceProviderFactoryProxy = await AudiusAdminUpgradeabilityProxy.new(
       serviceProviderFactory0.address,
@@ -567,6 +567,12 @@ contract('DelegateManager', async (accounts) => {
         testEndpoint,
         stakerAccount)
       let deregisterRequestInfo = await serviceProviderFactory.getPendingDecreaseStakeRequest(stakerAccount)
+
+      await _lib.assertRevert(
+        serviceProviderFactory.decreaseStake({ from: stakerAccount }),
+        'Lockup must be expired'
+      )
+
       await time.advanceBlockTo(deregisterRequestInfo.lockupExpiryBlock)
 
       // Withdraw all SP stake
@@ -1391,6 +1397,25 @@ contract('DelegateManager', async (accounts) => {
       )
     })
 
+    it('Fail to set service addresses from non-governance contract', async () => {
+      await _lib.assertRevert(
+        delegateManager.setGovernanceAddress(_lib.addressZero),
+        'Only governance'
+      )
+      await _lib.assertRevert(
+        delegateManager.setClaimsManagerAddress(_lib.addressZero),
+        'Only governance'
+      )
+      await _lib.assertRevert(
+        delegateManager.setServiceProviderFactoryAddress(_lib.addressZero),
+        'Only governance'
+      )
+      await _lib.assertRevert(
+        delegateManager.setStakingAddress(_lib.addressZero),
+        'Only governance'
+      )
+    })
+
     describe('Service provider decrease stake behavior', async () => {
       it('claimReward disabled if no active stake for SP', async () => {
         // Request decrease all of stake

eth-contracts/test/governance.test.js

@@ -132,8 +132,8 @@ contract('Governance.sol', async (accounts) => {
     const serviceProviderFactory0 = await ServiceProviderFactory.new({ from: proxyDeployerAddress })
     const serviceProviderFactoryCalldata = _lib.encodeCall(
       'initialize',
-      ['address', 'address'],
-      [registry.address, governance.address]
+      ['address'],
+      [governance.address]
     )
     const serviceProviderFactoryProxy = await AudiusAdminUpgradeabilityProxy.new(
       serviceProviderFactory0.address,

eth-contracts/test/serviceProvider.test.js

@@ -38,7 +38,8 @@ contract('ServiceProvider test', async (accounts) => {
   const [, proxyAdminAddress, proxyDeployerAddress, fakeGovernanceAddress] = accounts
   const tokenOwnerAddress = proxyDeployerAddress
   const guardianAddress = proxyDeployerAddress
-
+  const stakerAccount = accounts[11]
+  const stakerAccount2 = accounts[12]
   const callValue = _lib.toBN(0)
   const cnTypeMin = _lib.audToWei(10)
   const cnTypeMax = _lib.audToWei(10000000)
@@ -199,8 +200,8 @@ contract('ServiceProvider test', async (accounts) => {
     let serviceProviderFactory0 = await ServiceProviderFactory.new({ from: proxyDeployerAddress })
     const serviceProviderFactoryCalldata = _lib.encodeCall(
       'initialize',
-      ['address', 'address'],
-      [registry.address, governance.address]
+      ['address'],
+      [governance.address]
     )
     let serviceProviderFactoryProxy = await AudiusAdminUpgradeabilityProxy.new(
       serviceProviderFactory0.address,
@@ -242,6 +243,26 @@ contract('ServiceProvider test', async (accounts) => {
       _lib.addressZero
     )
 
+    await _lib.assertRevert(
+      _lib.registerServiceProvider(
+        token,
+        staking,
+        serviceProviderFactory,
+        testDiscProvType,
+        testEndpoint,
+        DEFAULT_AMOUNT,
+        stakerAccount
+      ),
+      'serviceTypeManagerAddress not set'
+    )
+
+    await _lib.assertRevert(
+      serviceProviderFactory.updateServiceProviderStake(
+        stakerAccount,
+        _lib.toBN(200)
+      ),
+      'delegateManagerAddress not set')
+
     await _lib.configureServiceProviderFactoryAddresses(
       governance,
       guardianAddress,
@@ -255,8 +276,6 @@ contract('ServiceProvider test', async (accounts) => {
   })
 
   describe('Registration flow', () => {
-    const stakerAccount = accounts[11]
-    const stakerAccount2 = accounts[12]
     let regTx
 
     beforeEach(async () => {
@@ -478,6 +497,10 @@ contract('ServiceProvider test', async (accounts) => {
       assert.isTrue(stakedAmount.eq(await staking.totalStakedFor(stakerAccount)), 'Expect no stake change')
     }
 
+    it('Confirm correct stake for account', async () => {
+      assert.isTrue((await getStakeAmountForAccount(stakerAccount)).eq(DEFAULT_AMOUNT))
+    })
+
     it('Fail to register invalid type', async () => {
       // Confirm invalid type cannot be registered
       await _lib.assertRevert(
@@ -494,10 +517,6 @@ contract('ServiceProvider test', async (accounts) => {
       )
     })
 
-    it('Confirm correct stake for account', async () => {
-      assert.isTrue((await getStakeAmountForAccount(stakerAccount)).eq(DEFAULT_AMOUNT))
-    })
-
     it('Deregister endpoint and confirm transfer of staking balance to owner', async () => {
       // Confirm staking contract has correct amt
       assert.isTrue((await getStakeAmountForAccount(stakerAccount)).eq(DEFAULT_AMOUNT))
@@ -858,14 +877,33 @@ contract('ServiceProvider test', async (accounts) => {
       )
     })
 
-    it('will fail to set the governance address from not current governance contract', async () => {
+    it('Fail to set service addresses from non-governance contract', async () => {
       await _lib.assertRevert(
         serviceProviderFactory.setGovernanceAddress(fakeGovernanceAddress),
         'Only callable by Governance contract'
       )
+      await _lib.assertRevert(
+        serviceProviderFactory.setStakingAddress(fakeGovernanceAddress),
+        'Only callable by Governance contract'
+      )
+
+      await _lib.assertRevert(
+        serviceProviderFactory.setDelegateManagerAddress(fakeGovernanceAddress),
+        'Only callable by Governance contract'
+      )
+
+      await _lib.assertRevert(
+        serviceProviderFactory.setServiceTypeManagerAddress(fakeGovernanceAddress),
+        'Only callable by Governance contract'
+      )
+
+      await _lib.assertRevert(
+        serviceProviderFactory.setClaimsManagerAddress(fakeGovernanceAddress),
+        'Only callable by Governance contract'
+      )
     })
 
-    it('will set the new governance address if called from current governance contract', async () => {
+    it('Will set the new governance address if called from current governance contract', async () => {
       assert.equal(
         governance.address,
         await serviceProviderFactory.getGovernanceAddress(),
@@ -887,6 +925,44 @@ contract('ServiceProvider test', async (accounts) => {
       )
     })
 
+    it('Claim pending and decrease stake restrictions', async () => {
+      await claimsManager.initiateRound({ from: stakerAccount })
+      await _lib.assertRevert(
+        _lib.registerServiceProvider(
+          token,
+          staking,
+          serviceProviderFactory,
+          testDiscProvType,
+          testEndpoint,
+          DEFAULT_AMOUNT,
+          stakerAccount
+        ),
+        'No claim expected to be pending prior to stake transfer'
+      )
+
+      await _lib.assertRevert(
+        serviceProviderFactory.requestDecreaseStake(
+          DEFAULT_AMOUNT.div(_lib.toBN(2)),
+          { from: stakerAccount }
+        ),
+        'No claim expected to be pending prior to stake transfer'
+      )
+
+      await _lib.assertRevert(
+        serviceProviderFactory.decreaseStake({ from: stakerAccount }),
+        'Decrease stake request must be pending'
+      )
+
+      await _lib.assertRevert(
+        serviceProviderFactory.cancelDecreaseStakeRequest(stakerAccount),
+        'Only callable from owner or DelegateManager'
+      )
+      await _lib.assertRevert(
+        serviceProviderFactory.cancelDecreaseStakeRequest(stakerAccount, { from: stakerAccount }),
+        'Decrease stake request must be pending'
+      )
+    })
+
     it('Service type operations test', async () => {
       let typeMinVal = _lib.audToWei(200)
       let typeMaxVal = _lib.audToWei(20000)
@@ -953,6 +1029,16 @@ contract('ServiceProvider test', async (accounts) => {
         'Expect invalid version prior to registration'
       )
 
+      // Confirm only governance can call set functions
+      await _lib.assertRevert(
+        serviceTypeManager.setGovernanceAddress(_lib.addressZero),
+        'Only governance'
+      )
+      await _lib.assertRevert(
+        serviceTypeManager.setServiceVersion(web3.utils.utf8ToHex('fake-type'), web3.utils.utf8ToHex('0.0')),
+        'Only callable by Governance contract'
+      )
+
       const setServiceVersionTxR = await governance.guardianExecuteTransaction(
         serviceTypeManagerProxyKey,
         callValue,

eth-contracts/test/staking.test.js

@@ -382,6 +382,48 @@ contract('Staking test', async (accounts) => {
       )
     })
 
+    it('Fail to set service addresses from non-governance contract, init test', async () => {
+      await _lib.assertRevert(
+        staking.setGovernanceAddress(_lib.addressZero),
+        'Only governance'
+      )
+      await _lib.assertRevert(
+        staking.setClaimsManagerAddress(_lib.addressZero),
+        'Only governance'
+      )
+      await _lib.assertRevert(
+        staking.setDelegateManagerAddress(_lib.addressZero),
+        'Only governance'
+      )
+      await _lib.assertRevert(
+        staking.setServiceProviderFactoryAddress(_lib.addressZero),
+        'Only governance'
+      )
+      await _lib.assertRevert(
+        staking.updateClaimHistory(0, accounts[5]),
+        'Only callable from ClaimsManager or Staking.sol'
+      )
+      let invalidStakingInitializeData = _lib.encodeCall(
+        'initialize',
+        ['address', 'address'],
+        [
+          accounts[5],
+          mockStakingCaller.address
+        ]
+      )
+      let staking1 = await Staking.new({ from: proxyAdminAddress })
+      // Confirm invalid token address fails on init
+      await _lib.assertRevert(
+        AudiusAdminUpgradeabilityProxy.new(
+          staking1.address,
+          proxyAdminAddress,
+          invalidStakingInitializeData,
+          mockStakingCaller.address,
+          { from: proxyDeployerAddress }
+        ),
+      )
+    })
+
     it('stakeRewards called from invalid address, ClaimsManager restriction', async () => {
       let staker = accounts[11]
       // Transfer 1000 tokens to accounts[11]