adjust copy fee logic and add some function into router

Author: spidemen

Makefile

@@ -17,6 +17,9 @@ deploy:
 deploy-router:
 	STORAGE_ADDRESS=$(STORAGE_ADDRESS) forge script ./script/DeployRouter.s.sol --rpc-url $(RPC_URL) --broadcast --private-key $(PRIVATE_KEY)
 
+upgrade-router:
+	PROXY_ADDRESS=$(PROXY_ADDRESS) STORAGE_ADDRESS=$(STORAGE_ADDRESS) forge script ./script/UpgradeRouter.s.sol --rpc-url $(RPC_URL) --broadcast --private-key $(PRIVATE_KEY)
+
 upgrade:
 	PROXY_ADDRESS=$(PROXY_ADDRESS) forge script ./script/Upgrade$(UPGRADE_TO).s.sol --rpc-url $(RPC_URL) --broadcast --private-key $(PRIVATE_KEY)
 

script/UpgradeRouter.s.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {Script, console} from "forge-std/Script.sol";
+import {Upgrades, Options} from "openzeppelin-foundry-upgrades/Upgrades.sol";
+import {BlueprintV3} from "../src/BlueprintV3.sol";
+
+contract DeployScript is Script {
+    function setUp() public {}
+
+    function run() public {
+        vm.startBroadcast();
+
+        address proxyAddr = vm.envAddress("PROXY_ADDRESS");
+        Options memory opts;
+        opts.referenceContract = "BlueprintV2.sol";
+        Upgrades.upgradeProxy(
+            proxyAddr, "BlueprintV3.sol:BlueprintV3", abi.encodeCall(BlueprintV3.initialize, ()), opts
+        );
+        BlueprintV3 proxy = BlueprintV3(proxyAddr);
+        console.log("New Version:", proxy.VERSION());
+
+        vm.stopBroadcast();
+    }
+}

src/Agent.sol

@@ -12,7 +12,9 @@ contract Agent is ERC2771Context, Payment {
     string public VERSION;
 
     event SetCopyAgentFee(bytes32 indexed agentRequestID, address userAddress, address tokenAddress, uint256 fee);
-    event CopyAgentRequest(bytes32 indexed copyID, bytes32 indexed originalAgentRequestID, address userAddress);
+    event CopyAgentRequest(
+        bytes32 indexed copyID, bytes32 indexed originalAgentRequestID, address userAddress, uint256 totalFee
+    );
 
     event UserTopUp(
         address indexed walletAddress, address feeCollectionWalletAddress, address tokenAddress, uint256 amount
@@ -35,8 +37,8 @@ contract Agent is ERC2771Context, Payment {
     }
 
     function setCopyAgentFee(bytes32 agentRequestID, address tokenAddress, uint256 fee) external {
-        require(fee > 0, "Fee must be greater than 0");
         require(Blueprint(blueprintStorageProxy).paymentAddressEnableMp(tokenAddress), "Invalid token address");
+
         address sender = _msgSender();
         require(Blueprint(blueprintStorageProxy).getDeploymentOwner(agentRequestID) == sender, "Not owner");
 
@@ -49,7 +51,6 @@ contract Agent is ERC2771Context, Payment {
     {
         address owner = Blueprint(blueprintStorageProxy).getDeploymentOwner(agentRequestID);
         require(owner != address(0), "Invalid agentRequestID");
-        require(fee > 0, "Fee must be greater than 0");
         require(Blueprint(blueprintStorageProxy).paymentAddressEnableMp(tokenAddress), "Invalid token address");
 
         uint256 nonce = Blueprint(blueprintStorageProxy).getUserNonce(owner);
@@ -103,17 +104,12 @@ contract Agent is ERC2771Context, Payment {
         address owner = Blueprint(blueprintStorageProxy).getDeploymentOwner(originalAgentRequestID);
         require(owner != address(0), "Invalid original agent request ID");
 
-        uint256 fee = Blueprint(blueprintStorageProxy).copyAgentFeeMp(originalAgentRequestID, tokenAddress);
-        require(fee > 0, "Copy Agent is not set by the owner");
-
+        uint256 platformFee = Blueprint(blueprintStorageProxy).platformFee(tokenAddress);
         // check platformFee is set or not
-        require(Blueprint(blueprintStorageProxy).platformCopyAgentFee() > 0, "Platform fee is not set");
-
+        require(platformFee > 0, "Platform fee is not set");
         // calculate platform and creator fees
-        uint256 platformFee =
-            (fee * Blueprint(blueprintStorageProxy).platformCopyAgentFee()) / Blueprint(blueprintStorageProxy).factor();
-
-        uint256 creatorFee = fee - platformFee;
+        uint256 totalFee = getCreateCopyAgentFee(originalAgentRequestID, tokenAddress);
+        uint256 creatorFee = totalFee - platformFee;
 
         address feeWallet = Blueprint(blueprintStorageProxy).feeCollectionWalletAddress();
         address fromAddr = getPaymentFromAddress();
@@ -125,9 +121,23 @@ contract Agent is ERC2771Context, Payment {
         payWithERC20(tokenAddress, platformFee, fromAddr, feeWallet);
 
         // pay the creator fee to the owner of the original agent request
-        payWithERC20(tokenAddress, creatorFee, fromAddr, owner);
+        if (creatorFee > 0) {
+            // if creator fee is greater than 0, we pay the creator fee to the owner
+            payWithERC20(tokenAddress, creatorFee, fromAddr, owner);
+        }
 
-        emit CopyAgentRequest(copyID, originalAgentRequestID, userAddress);
+        emit CopyAgentRequest(copyID, originalAgentRequestID, userAddress, totalFee);
+    }
+
+    function getCreateCopyAgentFee(bytes32 originalAgentRequestID, address tokenAddress)
+        public
+        view
+        returns (uint256)
+    {
+        require(Blueprint(blueprintStorageProxy).paymentAddressEnableMp(tokenAddress), "Invalid token address");
+        uint256 fee = Blueprint(blueprintStorageProxy).copyAgentFeeMp(originalAgentRequestID, tokenAddress);
+        uint256 platformFee = Blueprint(blueprintStorageProxy).platformFee(tokenAddress);
+        return (fee * platformFee) / Blueprint(blueprintStorageProxy).factor() + platformFee;
     }
 
     function createAgentWithToken(

src/Blueprint.sol

@@ -14,8 +14,9 @@ contract Blueprint is Initializable, OwnableUpgradeable, BlueprintCore {
     event SetWorkerAdmin(address workerAdmin);
     event UpdateWorker(address workerAddress, bool isTrusted);
     event CreditReward(address indexed userAddress, uint256 amount);
-    event SetGlobalPlatformFee(uint256 fee, uint256 factor);
+    event SetGlobalPlatformFee(uint256 baseFee, address paymentAddress);
     event SetAdminContract(address agentContract);
+    event RemoveAdminContract(address agentContract);
 
     modifier isAdmin() {
         // slither-disable-next-line timestamp
@@ -136,13 +137,17 @@ contract Blueprint is Initializable, OwnableUpgradeable, BlueprintCore {
         emit SetAdminContract(_adminContract);
     }
 
-    // 6 %。=  6 / 100  means fee =6 and baseFactor = 100
-    function setGlobalPlatformFee(uint256 fee, uint256 baseFactor) public isAdmin {
+    function removeAdminContract(address _adminContract) public onlyOwner {
+        require(_adminContract != address(0), "Admin contract address is invalid");
+        delete adminContracts[_adminContract];
+        emit RemoveAdminContract(_adminContract);
+    }
+
+    // nation token fee is a global fee that applies to all agents
+    function setGlobalPlatformFee(uint256 baseFee, address paymentAddress) public isAdmin {
         // base factor should be greater or equal than 10
-        require(baseFactor >= 10, "Base factor should be greater than or equal to 10");
-        require(fee <= baseFactor, "Fee cannot be greater than factor");
-        factor = baseFactor;
-        platformCopyAgentFee = fee;
-        emit SetGlobalPlatformFee(fee, baseFactor);
+        require(paymentAddressEnableMp[paymentAddress], "Payment Address is not added");
+        platformFee[paymentAddress] = baseFee;
+        emit SetGlobalPlatformFee(baseFee, paymentAddress);
     }
 }

src/BlueprintCore.sol

@@ -113,7 +113,7 @@ contract BlueprintCore is Initializable, EIP712, Payment {
 
     // agent copy fee mapping
     mapping(address => bool) public adminContracts;
-    uint256 public platformCopyAgentFee;
+    mapping(address => uint256) public platformFee;
     mapping(bytes32 => mapping(address => uint256)) public copyAgentFeeMp;
 
     event CreateProjectID(bytes32 indexed projectID, address walletAddress);
@@ -207,7 +207,6 @@ contract BlueprintCore is Initializable, EIP712, Payment {
         // (if you ever add state, initialize it here)
         // default factor
         factor = 1000; // 100% factor
-        platformCopyAgentFee = 100; // 1% platform fee for copy agent
     }
 
     // slither-disable-end naming-convention

src/RouterV1.sol

@@ -57,11 +57,11 @@ contract RouterV1 is Initializable, OwnableUpgradeable, UUPSUpgradeable, Payment
         external
         payable
     {
-        uint256 fee = Blueprint(blueprint).copyAgentFeeMp(originalAgentRequestID, tokenAddress);
+        uint256 totalFee = Agent(agent).getCreateCopyAgentFee(originalAgentRequestID, tokenAddress);
         // transfer funds to agent
         if (tokenAddress != address(0)) {
             // transfer ERC20 tokens to agent
-            payWithERC20(tokenAddress, fee, msg.sender, agent);
+            payWithERC20(tokenAddress, totalFee, msg.sender, agent);
         }
 
         bytes memory data = abi.encodeWithSelector(
@@ -80,7 +80,7 @@ contract RouterV1 is Initializable, OwnableUpgradeable, UUPSUpgradeable, Payment
         address tokenAddress,
         bytes memory signature
     ) external payable {
-        uint256 fee = Blueprint(blueprint).copyAgentFeeMp(originalAgentRequestID, tokenAddress);
+        uint256 totalFee = Agent(agent).getCreateCopyAgentFee(originalAgentRequestID, tokenAddress);
 
         // get digest
         bytes32 digest =
@@ -91,7 +91,7 @@ contract RouterV1 is Initializable, OwnableUpgradeable, UUPSUpgradeable, Payment
         // transfer funds to agent
         if (tokenAddress != address(0)) {
             // transfer ERC20 tokens to agent
-            payWithERC20(tokenAddress, fee, signer, agent);
+            payWithERC20(tokenAddress, totalFee, signer, agent);
         }
 
         Agent(agent).createCopyAgentRequestWithSig{value: msg.value}(
@@ -161,6 +161,15 @@ contract RouterV1 is Initializable, OwnableUpgradeable, UUPSUpgradeable, Payment
         );
     }
 
+    // add getCreateCopyAgentFee from agent contract into Router
+    function getCreateCopyAgentFee(bytes32 originalAgentRequestID, address tokenAddress)
+        external
+        view
+        returns (uint256)
+    {
+        return Blueprint(blueprint).copyAgentFeeMp(originalAgentRequestID, tokenAddress);
+    }
+
     // --- Payment/TopUp ---
     function userTopUp(address tokenAddress, uint256 amount) external payable {
         // transfer funds to agent

test/Agent.t.sol

@@ -96,7 +96,8 @@ contract AgentTest is Test {
             agent.createAgentWithToken(projectId, base64Proposal, workerAddress, serverURL, address(mockToken));
 
         // set copy agent fee to 1000
-        uint256 copyAgentFee = 1000;
+        uint256 copyAgentFee = 10; // 10 percent
+        uint256 baseFee = 1000000; // 100000 token
 
         // Expect revert because agentContract is not set in Blueprint
         //        vm.expectRevert("Only Agent contract allow");
@@ -111,9 +112,12 @@ contract AgentTest is Test {
         );
 
         // creator not set copy fee
-        vm.expectRevert("Copy Agent is not set by the owner");
+        vm.expectRevert("Platform fee is not set");
         agent.createCopyAgentRequest(copyID, requestId, address(mockToken));
 
+        // set platform fee
+        blueprint.setGlobalPlatformFee(baseFee, address(mockToken)); // 100000 token
+
         // set copy agent fee
         vm.expectEmit(true, true, true, true);
         emit Agent.SetCopyAgentFee(requestId, address(this), address(mockToken), copyAgentFee);
@@ -124,30 +128,34 @@ contract AgentTest is Test {
         agent.createCopyAgentRequest(copyID, requestId, address(mockToken));
 
         // transfer some mock tokens to the sender
-        mockToken.mint(address(this), copyAgentFee);
+        uint256 totalFee = agent.getCreateCopyAgentFee(requestId, address(mockToken));
+        mockToken.mint(address(this), totalFee);
 
         // revert: not grant allowance to Agent contract
         vm.expectRevert("ERC20: transfer amount exceeds allowance");
         agent.createCopyAgentRequest(copyID, requestId, address(mockToken));
 
         // grant allowance to blueprint address
-        mockToken.approve(address(agent), copyAgentFee);
+        mockToken.approve(address(agent), totalFee);
 
         // owner cannot create copy agent request
         vm.expectRevert("Cannot transfer to self address");
         agent.createCopyAgentRequest(copyID, requestId, address(mockToken));
 
         // transfer some mock tokens to relayer
         address relayer = address(0xBEEF);
-        mockToken.mint(relayer, copyAgentFee);
+        mockToken.mint(relayer, totalFee);
         vm.prank(relayer);
 
         // grant allowance to blueprint address
-        mockToken.approve(address(agent), copyAgentFee);
+        mockToken.approve(address(agent), totalFee);
+
+        uint256 platformFee = blueprint.platformFee(address(mockToken));
+        uint256 creatorFee = (copyAgentFee * platformFee) / blueprint.factor();
 
         // Expect the CopyAgentRequest event (from Agent, which emits the same event)
         vm.expectEmit(true, false, false, false);
-        emit Agent.CopyAgentRequest(copyID, requestId, address(this));
+        emit Agent.CopyAgentRequest(copyID, requestId, address(this), platformFee + creatorFee);
 
         // creator balance before creating copy agent request
         uint256 creatorBalanceBefore = mockToken.balanceOf(address(this));
@@ -157,8 +165,6 @@ contract AgentTest is Test {
         agent.createCopyAgentRequest(copyID, requestId, address(mockToken));
 
         // check fee collect wallet balance and creator balance
-        uint256 platformFee = (copyAgentFee * blueprint.platformCopyAgentFee()) / blueprint.factor();
-        uint256 creatorFee = copyAgentFee - platformFee;
         uint256 feeCollectionWalletBalance = mockToken.balanceOf(blueprint.feeCollectionWalletAddress());
         // creator balance after creating copy agent request
         uint256 creatorBalanceAfter = mockToken.balanceOf(address(this));
@@ -192,7 +198,7 @@ contract AgentTest is Test {
             projectId, base64Proposal, workerAddress, serverURL, address(mockToken), createAgentSig
         );
         // Set copy agent fee using gasless signature
-        uint256 copyAgentFee = 1000;
+        uint256 copyAgentFee = 100; // 100 / 1000(factor) percent
         uint256 nonce = blueprint.getUserNonce(owner);
         bytes32 digest = blueprint.getSetCopyAgentFeeDigest(requestId, address(mockToken), copyAgentFee, nonce);
         (uint8 v, bytes32 r, bytes32 s) = vm.sign(signerPrivateKey, digest);
@@ -215,7 +221,13 @@ contract AgentTest is Test {
         string memory serverURL = "app.crestal.network";
 
         // Mint and approve tokens for owner (not relayer)
-        uint256 copyAgentFee = 1000;
+        uint256 copyAgentFee = 100; // 100 / 1000 (factor) percent
+
+        uint256 baseFee = 1000000; // 100000 token
+        uint256 totalFee = baseFee + (copyAgentFee * baseFee) / blueprint.factor();
+        // Set the global platform fee
+        blueprint.setGlobalPlatformFee(baseFee, address(mockToken)); // 100000 token
+
         //  0 cost, no need to set allowance and mint tokens
         // Create agent with token, owner is address(this)
         bytes32 requestId =
@@ -234,16 +246,16 @@ contract AgentTest is Test {
         bytes memory signature = abi.encodePacked(r, s, v);
 
         // Mint and approve tokens for owner (not relayer)
-        mockToken.mint(user, copyAgentFee);
+        mockToken.mint(user, totalFee);
         vm.prank(user);
-        mockToken.approve(address(agent), copyAgentFee);
+        mockToken.approve(address(agent), totalFee);
 
         // Record balances before
         uint256 ownerBalanceBefore = mockToken.balanceOf(user);
 
         // Expect event
-        vm.expectEmit(true, true, true, true);
-        emit Agent.CopyAgentRequest(copyID, requestId, user);
+        vm.expectEmit(true, true, true, false);
+        emit Agent.CopyAgentRequest(copyID, requestId, user, 0);
 
         // Relayer submits the gasless request
         vm.prank(relayer);
@@ -252,6 +264,6 @@ contract AgentTest is Test {
         // Check relayer balance is unchanged (should be 0)
         assertEq(mockToken.balanceOf(relayer), 0, "Relayer balance should be 0 after gasless copy agent request");
         // Check owner's balance is reduced by the fee
-        assertEq(mockToken.balanceOf(user), ownerBalanceBefore - copyAgentFee, "Owner should pay the copy agent fee");
+        assertEq(mockToken.balanceOf(user), ownerBalanceBefore - totalFee, "Owner should pay the copy agent fee");
     }
 }

test/BlueprintV7.t.sol

@@ -40,15 +40,17 @@ contract BlueprintTest is Test {
     }
 
     function test_setGlobalPlatformFee() public {
+        // Add the payment address
+        blueprint.addPaymentAddress(address(mockToken));
         // Set the global platform fee to 5%
-        uint256 newFee = 5; // 5% in basis points
-        blueprint.setGlobalPlatformFee(newFee, 100);
+        uint256 baseFee = 100000; // 100000 nation token
+        blueprint.setGlobalPlatformFee(baseFee, address(mockToken));
         // Retrieve the global platform fee
-        uint256 fee = blueprint.platformCopyAgentFee();
+        uint256 fee = blueprint.platformFee(address(mockToken));
         // Assert that the fee is set correctly
-        assertEq(fee, newFee);
+        assertEq(fee, baseFee);
         // factor check
-        assertEq(100, blueprint.factor());
+        assertEq(1000, blueprint.factor());
     }
 
     function test_updateWorkerDeploymentConfig() public {