Reserve supports multiple exchanges

packages/protocol/contracts/stability/Reserve.sol

@@ -311,6 +311,11 @@ contract Reserve is
     emit SpenderRemoved(spender);
   }
 
+  function _isAllowedToSpendExchange(address spender) private view returns (bool) {
+    return
+      isExchangeSpender[spender] || (registry.getAddressForOrDie(EXCHANGE_REGISTRY_ID) == spender);
+  }
+
   /**
    * @notice Gives an address permission to spend Reserve without limit.
    * @param spender The address that is allowed to spend Reserve funds.
@@ -385,7 +390,7 @@ contract Reserve is
    * @return Returns true if the transaction succeeds.
    */
   function transferExchangeGold(address payable to, uint256 value) external returns (bool) {
-    require(isExchangeSpender[msg.sender], "a non-exchangeSpender can't start a transfer");
+    require(_isAllowedToSpendExchange(msg.sender), "Address not allowed to spend");
     return _transferGold(to, value);
   }
 

packages/protocol/test/stability/reserve.ts

@@ -36,6 +36,7 @@ contract('Reserve', (accounts: string[]) => {
   const nonOwner: string = accounts[1]
   const spender: string = accounts[2]
   const exchangeAddress: string = accounts[3]
+  const exchangeSpenderAddress: string = accounts[4]
   const aTobinTaxStalenessThreshold: number = 600
   const aTobinTax = toFixed(0.005)
   const aTobinTaxReserveRatio = toFixed(2)
@@ -291,13 +292,13 @@ contract('Reserve', (accounts: string[]) => {
     })
 
     it('should emit addExchangeSpender event on add', async () => {
-      const resp = await reserve.addExchangeSpender(exchangeAddress)
+      const resp = await reserve.addExchangeSpender(exchangeSpenderAddress)
       const log = resp.logs[0]
       assert.equal(resp.logs.length, 1)
       assertLogMatches2(log, {
         event: 'ExchangeSpenderAdded',
         args: {
-          exchangeSpender: exchangeAddress,
+          exchangeSpender: exchangeSpenderAddress,
         },
       })
     })
@@ -314,57 +315,59 @@ contract('Reserve', (accounts: string[]) => {
 
   describe('#removeExchangeSpender(exchangeAddress)', () => {
     beforeEach(async () => {
-      await reserve.addExchangeSpender(exchangeAddress)
+      await reserve.addExchangeSpender(exchangeSpenderAddress)
     })
 
     it('only allows owner', async () => {
       await assertRevert(reserve.removeExchangeSpender(nonOwner, 0, { from: nonOwner }))
     })
 
+    // TODO should allow exchange
+
     it('should emit removeExchangeSpender event on remove', async () => {
-      const resp = await reserve.removeExchangeSpender(exchangeAddress, 0)
+      const resp = await reserve.removeExchangeSpender(exchangeSpenderAddress, 0)
       const log = resp.logs[0]
       assert.equal(resp.logs.length, 1)
       assertLogMatches2(log, {
         event: 'ExchangeSpenderRemoved',
         args: {
-          exchangeSpender: exchangeAddress,
+          exchangeSpender: exchangeSpenderAddress,
         },
       })
     })
 
     it('has the right list of exchange spenders', async () => {
       const spenders = await reserve.getExchangeSpenders()
       assert.equal(spenders.length, 1)
-      assert.equal(spenders[0], exchangeAddress)
+      assert.equal(spenders[0], exchangeSpenderAddress)
     })
 
     it('has the right list of exchange after removing one', async () => {
-      await reserve.removeExchangeSpender(exchangeAddress, 0)
+      await reserve.removeExchangeSpender(exchangeSpenderAddress, 0)
       const spenders = await reserve.getExchangeSpenders()
       assert.equal(spenders.length, 0)
     })
 
     it("can't be removed twice", async () => {
-      await reserve.removeExchangeSpender(exchangeAddress, 0)
-      await assertRevert(reserve.removeExchangeSpender(exchangeAddress, 0))
+      await reserve.removeExchangeSpender(exchangeSpenderAddress, 0)
+      await assertRevert(reserve.removeExchangeSpender(exchangeSpenderAddress, 0))
     })
 
     it("can't delete an index out of range", async () => {
-      await assertRevert(reserve.removeExchangeSpender(exchangeAddress, 1))
+      await assertRevert(reserve.removeExchangeSpender(exchangeSpenderAddress, 1))
     })
 
     it('removes from a big array', async () => {
       await reserve.addExchangeSpender(accounts[1])
-      await reserve.removeExchangeSpender(exchangeAddress, 0)
+      await reserve.removeExchangeSpender(exchangeSpenderAddress, 0)
       const spenders = await reserve.getExchangeSpenders()
       assert.equal(spenders.length, 1)
       assert.equal(spenders[0], accounts[1])
     })
 
     it("doesn't remove an address with the wrong index", async () => {
       await reserve.addExchangeSpender(accounts[1])
-      assertRevert(reserve.removeExchangeSpender(exchangeAddress, 1))
+      assertRevert(reserve.removeExchangeSpender(exchangeSpenderAddress, 1))
     })
   })
 
@@ -402,7 +405,6 @@ contract('Reserve', (accounts: string[]) => {
       await web3.eth.sendTransaction({ to: reserve.address, value: aValue, from: accounts[0] })
       await reserve.addSpender(spender)
       await reserve.addOtherReserveAddress(otherReserveAddress)
-      await reserve.addExchangeSpender(exchangeAddress)
     })
 
     it('should allow an exchange to call transferExchangeGold', async () => {
@@ -418,8 +420,11 @@ contract('Reserve', (accounts: string[]) => {
     })
 
     it('should not allow removed exchange spender addresses to call transferExchangeGold', async () => {
-      await reserve.removeExchangeSpender(exchangeAddress, 0)
-      await assertRevert(reserve.transferExchangeGold(nonOwner, aValue, { from: exchangeAddress }))
+      await reserve.addExchangeSpender(exchangeSpenderAddress)
+      await reserve.removeExchangeSpender(exchangeSpenderAddress, 0)
+      await assertRevert(
+        reserve.transferExchangeGold(nonOwner, aValue, { from: exchangeSpenderAddress })
+      )
     })
 
     it('should not allow freezing more gold than is available', async () => {