new hierachy: ServiceManager - ServiceController - Service - Instance

Signed-off-by: Alexander Diemand <codieplusplus@apax.net>

Author: CodiePP

bca-token-solidity/README.md

@@ -23,7 +23,7 @@ npx hardhat node
 in the other deploy the contract
 ```sh
 npx hardhat ignition deploy ignition/modules/BCA_Token.ts --network localhost
-npx hardhat ignition deploy ignition/modules/BCA_Service.ts --network localhost
+npx hardhat ignition deploy ignition/modules/BCA_ServiceManager.ts --network localhost
 ```
 
 #### Connect metamask to local node

bca-token-solidity/contracts/BCA_ServiceController.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.24;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+import "./Iface_ServiceController.sol";
+import "./BCA_Service.sol";
+
+// Factory contract that deploys service contracts
+contract BCAServiceController is IServiceController, ReentrancyGuard {
+    using SafeERC20 for IERC20;
+
+    IERC20 public immutable tokToken;
+    address public immutable providerAddress;
+    address[] public deployedServices;
+    
+    // Event to notify when a new service is deployed
+    event ServiceDeployed(address contractAddress);
+
+    constructor(address setProviderAddress, address tokAddress) {
+        require(setProviderAddress != address(0), "Invalid provider address");
+        require(tokAddress != address(0), "Invalid token address");
+
+        tokToken = IERC20(tokAddress);
+        providerAddress = setProviderAddress;
+    }
+
+    function newService(uint16 maxInstances, uint256 dayPrice) external nonReentrant returns (address) {
+        // Create a new SimpleContract
+        BCAService serviceContract = new BCAService(providerAddress, address(tokToken), maxInstances, dayPrice);
+        
+        // Store the address
+        deployedServices.push(address(serviceContract));
+        
+        // Emit event
+        emit ServiceDeployed(address(serviceContract));
+        
+        return address(serviceContract);
+    }
+    
+    function countServiceContracts() public view returns (uint) {
+        return deployedServices.length;
+    }
+}

bca-token-solidity/contracts/BCA_ServiceManager.sol

@@ -5,41 +5,56 @@ import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
 import "./Iface_ServiceManager.sol";
-import "./BCA_Service.sol";
+import "./BCA_ServiceController.sol";
 
 // Factory contract that deploys service contracts
 contract BCAServiceManager is IServiceManager, ReentrancyGuard {
     using SafeERC20 for IERC20;
 
     IERC20 public immutable tokToken;
-    address public immutable providerAddress;
-    address[] public deployedServices;
+
+    struct ControllerStruct {
+        address addrContract;
+        bool isDeployed;
+    }
+    mapping (address => ControllerStruct) public deployedControllers;
+    address[] public addressControllers;
 
     // Event to notify when a new service is deployed
-    event ServiceDeployed(address contractAddress);
+    event ControllerDeployed(address contractAddress);
 
-    constructor(address setProviderAddress, address tokAddress) {
-        require(setProviderAddress != address(0), "Invalid provider address");
+    constructor(address tokAddress) {
         require(tokAddress != address(0), "Invalid token address");
 
         tokToken = IERC20(tokAddress);
-        providerAddress = setProviderAddress;
     }
 
-    function newService(uint16 maxInstances, uint256 dayPrice) external nonReentrant returns (address) {
+    function getControllerAddress(address providerAddress) public view returns(address addrController) {
+        require (deployedControllers[providerAddress].isDeployed == true, "no controller for this provider");
+        return deployedControllers[providerAddress].addrContract;
+    }
+
+    function isDeployed(address providerAddress) public view returns(bool isdeployed) {
+        if (addressControllers.length == 0) return false;
+        return (deployedControllers[providerAddress].isDeployed);
+    }
+
+    function newController(address providerAddress) external nonReentrant {
+        require(! isDeployed(providerAddress), "already deployed controller for this provider");
+
         // Create a new SimpleContract
-        BCAService serviceContract = new BCAService(providerAddress, address(tokToken), maxInstances, dayPrice);
+        BCAServiceController controllerContract = new BCAServiceController(providerAddress, address(tokToken));
 
         // Store the address
-        deployedServices.push(address(serviceContract));
+        addressControllers.push(address(controllerContract));
+        deployedControllers[providerAddress].addrContract = address(controllerContract);
+        deployedControllers[providerAddress].isDeployed = true;
 
         // Emit event
-        emit ServiceDeployed(address(serviceContract));
-        
-        return address(serviceContract);
+        emit ControllerDeployed(address(controllerContract));
     }
-    
-    function countServiceContracts() public view returns (uint) {
-        return deployedServices.length;
+
+    function countServiceControllers() public view returns (uint) {
+        return addressControllers.length;
     }
 }

bca-token-solidity/contracts/Iface_ServiceController.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.24;
+
+interface IServiceController {
+        function newService(uint16 _maxInstances, uint256 _dayPrice) external returns (address);
+}

bca-token-solidity/contracts/Iface_ServiceManager.sol

@@ -2,5 +2,5 @@
 pragma solidity ^0.8.24;
 
 interface IServiceManager {
-        function newService(uint16 _maxInstances, uint256 _dayPrice) external returns (address);
+        function newController(address providerAddress) external;
 }

bca-token-solidity/ignition/modules/BCA_ServiceManager.ts

@@ -12,7 +12,7 @@ let provider = "0x8626f6940E2eb28930eFb4CeF49B2d1F2C9C1199"
 
 const BCAServiceManagerModule = buildModule("BCA_ServiceManager", (m) => {
 
-    const bcasrvmgr = m.contract("BCAServiceManager", [provider, deployed_address["BCA_Token#BCAServiceToken"]]);
+    const bcasrvmgr = m.contract("BCAServiceManager", [deployed_address["BCA_Token#BCAServiceToken"]]);
 
     return { bcasrvmgr };
   });

bca-token-solidity/test/BCA_ServiceManager.ts

@@ -18,11 +18,13 @@ import {
         const tokenContract = await Token.deploy("Test token", "TOK1", minter, burner);
         const precision: bigint = await tokenContract.decimals().then(d => { if (d == 0n) {return 18n;} else {return d}; });
 
-        const Contract1 = await hre.ethers.getContractFactory("BCAServiceManager");
-        const serviceManager1 = await Contract1.deploy(provider1, tokenContract.getAddress());
+        const Manager = await hre.ethers.getContractFactory("BCAServiceManager");
+        const serviceManager = await Manager.deploy(tokenContract.getAddress());
 
-        const Contract2 = await hre.ethers.getContractFactory("BCAServiceManager");
-        const serviceManager2 = await Contract1.deploy(provider2, tokenContract.getAddress());
+        const addrController1 = await (await serviceManager.connect(owner).newController(provider1)).wait().then(_ => serviceManager.connect(owner).getControllerAddress(provider1));
+        const serviceController1 = await hre.ethers.getContractAt("BCAServiceController", addrController1)
+        const addrController2 = await (await serviceManager.connect(owner).newController(provider2)).wait().then(_ => serviceManager.connect(owner).getControllerAddress(provider2));
+        const serviceController2 = await hre.ethers.getContractAt("BCAServiceController", addrController2)
 
         // minting some tokens to the users
         const one_token = 1n * BigInt(10n**precision);
@@ -34,35 +36,43 @@ import {
         const startblocktime: bigint = BigInt(await time.increase(30));
 
         return { token: { tokenContract, one_token, owner, minter, burner, user1, user2 },
-                 sm1: { serviceManager1, provider1 },
-                 sm2: { serviceManager2, provider2 } };
+                 sm: { serviceManager, provider1, provider2 },
+                 sc1: { serviceController1, provider1 },
+                 sc2: { serviceController2, provider2 } };
     }
 
     describe("Deployment", function () {
-        it("Funding contract: should set the right provider", async function () {
-            const { sm1 } = await loadFixture(deployContract);
-            expect(await sm1.serviceManager1.providerAddress()).to.equal(
-                sm1.provider1.address
+        it("Should have already deployed controllers", async function () {
+            const { sm } = await loadFixture(deployContract);
+            expect(await sm.serviceManager.countServiceControllers()).to.equal(
+                2
             );
         });
 
-        it("Funding contract: should set the right provider", async function () {
-            const { sm2 } = await loadFixture(deployContract);
-            expect(await sm2.serviceManager2.providerAddress()).to.equal(
-                sm2.provider2.address
+        it("Should set the right provider", async function () {
+            const { sc1 } = await loadFixture(deployContract);
+            expect(await sc1.serviceController1.providerAddress()).to.equal(
+                sc1.provider1.address
+            );
+        });
+
+        it("Should set the right provider", async function () {
+            const { sc2 } = await loadFixture(deployContract);
+            expect(await sc2.serviceController2.providerAddress()).to.equal(
+                sc2.provider2.address
             );
         });
     });
 
     describe("Create new services", function () {
         it("Should emit ServiceDeployed on new service creation", async function () {
-            const { sm1, sm2 } = await loadFixture(deployContract);
+            const { sc1, sc2 } = await loadFixture(deployContract);
 
-            await expect(sm1.serviceManager1.connect(sm1.provider1).newService(3, 1n * 10n**18n))
-                .to.emit(sm1.serviceManager1, "ServiceDeployed")
+            await expect(sc1.serviceController1.connect(sc1.provider1).newService(3, 1n * 10n**18n))
+                .to.emit(sc1.serviceController1, "ServiceDeployed")
                 .withArgs(anyValue);
-            await expect(sm2.serviceManager2.connect(sm2.provider2).newService(99, 1n * 10n**18n / 10n))
-                .to.emit(sm2.serviceManager2, "ServiceDeployed")
+            await expect(sc2.serviceController2.connect(sc2.provider2).newService(99, 1n * 10n**18n / 10n))
+                .to.emit(sc2.serviceController2, "ServiceDeployed")
                 .withArgs(anyValue);
         });