Require pools to have sufficient first loss minimum

contracts/PoolFactory.sol

@@ -56,6 +56,13 @@ contract PoolFactory is IPoolFactory {
                 "PoolFactory: Invalid fixed fee interval"
             );
         }
+        require(
+            settings.firstLossInitialMinimum >=
+                IServiceConfiguration(_serviceConfiguration).firstLossMinimum(
+                    liquidityAsset
+                ),
+            "PoolFactory: Invalid first loss minimum"
+        );
 
         // Create the pool
         Pool pool = new Pool(

contracts/ServiceConfiguration.sol

@@ -21,6 +21,8 @@ contract ServiceConfiguration is AccessControl, IServiceConfiguration {
 
     mapping(address => bool) public isLiquidityAsset;
 
+    mapping(address => uint256) private _firstLossMinimum;
+
     uint256 public firstLossFeeBps = 500;
 
     address public tosAcceptanceRegistry;
@@ -40,6 +42,11 @@ contract ServiceConfiguration is AccessControl, IServiceConfiguration {
      */
     event LiquidityAssetSet(address addr, bool value);
 
+    /**
+     * @dev Emitted when first loss minimum is set for an asset.
+     */
+    event FirstLossMinimumSet(address addr, uint256 value);
+
     /**
      * @dev Emitted when a parameter is set.
      */
@@ -127,6 +134,30 @@ contract ServiceConfiguration is AccessControl, IServiceConfiguration {
         emit TermsOfServiceRegistrySet(addr);
     }
 
+    /**
+     * @inheritdoc IServiceConfiguration
+     */
+    function setFirstLossMinimum(address addr, uint256 value)
+        external
+        override
+        onlyOperator
+    {
+        _firstLossMinimum[addr] = value;
+        emit FirstLossMinimumSet(addr, value);
+    }
+
+    function firstLossMinimum(address addr)
+        external
+        view
+        override
+        returns (uint256)
+    {
+        return _firstLossMinimum[addr];
+    }
+
+    /**
+     * @inheritdoc IServiceConfiguration
+     */
     function setFirstLossFeeBps(uint256 value) external override onlyOperator {
         firstLossFeeBps = value;
         emit ParameterSet("firstLossFeeBps", value);

contracts/interfaces/IServiceConfiguration.sol

@@ -14,6 +14,8 @@ interface IServiceConfiguration is IAccessControl {
 
     function paused() external view returns (bool);
 
+    function firstLossMinimum(address addr) external view returns (uint256);
+
     function firstLossFeeBps() external view returns (uint256);
 
     function isLiquidityAsset(address addr) external view returns (bool);
@@ -40,6 +42,13 @@ interface IServiceConfiguration is IAccessControl {
      */
     function setToSAcceptanceRegistry(address addr) external;
 
+    /**
+     * @dev Sets the first loss minimum for the given asset
+     * @param addr address of the liquidity asset
+     * @param value the minimum tokens required to be deposited by pool admins
+     */
+    function setFirstLossMinimum(address addr, uint256 value) external;
+
     /**
      * @dev Sets the first loss fee for the protocol
      * @param value amount of each payment that is allocated to the first loss vault. Value is in basis points, e.g. 500 equals 5%.

test/PoolFactory.test.ts

@@ -51,7 +51,8 @@ describe("PoolFactory", () => {
 
     return {
       poolFactory,
-      liquidityAsset
+      liquidityAsset,
+      serviceConfiguration
     };
   }
 
@@ -66,6 +67,22 @@ describe("PoolFactory", () => {
     ).to.be.revertedWith("PoolFactory: Invalid duration");
   });
 
+  it("reverts if the first loss minimum is not sufficient", async () => {
+    const { serviceConfiguration, poolFactory, liquidityAsset } =
+      await loadFixture(deployFixture);
+
+    // Set a first loss minimum
+    await serviceConfiguration.setFirstLossMinimum(liquidityAsset.address, 1);
+
+    // Attempt to create a pool with 0 first loss minimum
+    const poolSettings = Object.assign({}, DEFAULT_POOL_SETTINGS, {
+      firstLossInitialMinimum: 0 // $0
+    });
+    await expect(
+      poolFactory.createPool(liquidityAsset.address, poolSettings)
+    ).to.be.revertedWith("PoolFactory: Invalid first loss minimum");
+  });
+
   it("emits PoolCreated", async () => {
     const { poolFactory, liquidityAsset } = await loadFixture(deployFixture);
 

test/ServiceConfiguration.test.ts

@@ -130,6 +130,43 @@ describe("ServiceConfiguration", () => {
     });
   });
 
+  describe("first loss minimums", () => {
+    it("default to 0 for any given token", async () => {
+      const { serviceConfiguration } = await loadFixture(deployFixture);
+
+      const { mockERC20 } = await deployMockERC20();
+
+      expect(
+        await serviceConfiguration.firstLossMinimum(
+          "0x0000000000000000000000000000000000000000"
+        )
+      ).to.equal(0);
+
+      expect(
+        await serviceConfiguration.firstLossMinimum(mockERC20.address)
+      ).to.equal(0);
+    });
+
+    it("can be updated", async () => {
+      const { serviceConfiguration } = await loadFixture(deployFixture);
+
+      const { mockERC20 } = await deployMockERC20();
+
+      expect(
+        await serviceConfiguration.firstLossMinimum(mockERC20.address)
+      ).to.equal(0);
+
+      await serviceConfiguration.setFirstLossMinimum(
+        mockERC20.address,
+        10_000_000000 // $10,000
+      );
+
+      expect(
+        await serviceConfiguration.firstLossMinimum(mockERC20.address)
+      ).to.equal(10_000_000000);
+    });
+  });
+
   describe("setFirstLossFeeBps", () => {
     it("can only be called by the operator", async () => {
       const { serviceConfiguration, operator, otherAccount } =