another big refactor add worker contract and payment

Author: spidemen

script/UpgradeV7.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 {BlueprintV6} from "../src/BlueprintV6.sol";
+
+contract DeployScript is Script {
+    function setUp() public {}
+
+    function run() public {
+        vm.startBroadcast();
+
+        address proxyAddr = vm.envAddress("PROXY_ADDRESS");
+        Options memory opts;
+        opts.referenceContract = "BlueprintV5.sol";
+        Upgrades.upgradeProxy(
+            proxyAddr, "BlueprintV6.sol:BlueprintV6", abi.encodeCall(BlueprintV6.initialize, ()), opts
+        );
+        BlueprintV6 proxy = BlueprintV6(proxyAddr);
+        console.log("New Version:", proxy.VERSION());
+
+        vm.stopBroadcast();
+    }
+}

src/Agent.sol

@@ -6,8 +6,10 @@ import "@openzeppelin/contracts/metatx/ERC2771Context.sol";
 import "./Payment.sol";
 import "./Blueprint.sol";
 
-contract Agent is ERC2771Context {
-    address public blueprintCore;
+contract Agent is ERC2771Context, Payment {
+    address public blueprintStorageProxy;
+    address public trustRouter;
+    string public VERSION;
 
     event SetCopyAgentFee(bytes32 indexed agentRequestID, address userAddress, address tokenAddress, uint256 fee);
     event CopyAgentRequest(bytes32 indexed copyID, bytes32 indexed originalAgentRequestID, address userAddress);
@@ -24,36 +26,41 @@ contract Agent is ERC2771Context {
         uint256 amount
     );
 
-    constructor(address _core, address trustedForwarder) ERC2771Context(trustedForwarder) {
-        blueprintCore = _core;
+    constructor(address _blueprintStorageProxy, address _trustedForwarder, string memory _version)
+        ERC2771Context(_trustedForwarder)
+    {
+        trustRouter = _trustedForwarder;
+        blueprintStorageProxy = _blueprintStorageProxy;
+        VERSION = _version;
     }
 
     function setCopyAgentFee(bytes32 agentRequestID, address tokenAddress, uint256 fee) external {
         require(fee > 0, "Fee must be greater than 0");
-        require(Blueprint(blueprintCore).paymentAddressEnableMp(tokenAddress), "Invalid token address");
+        require(Blueprint(blueprintStorageProxy).paymentAddressEnableMp(tokenAddress), "Invalid token address");
         address sender = _msgSender();
-        require(Blueprint(blueprintCore).getDeploymentOwner(agentRequestID) == sender, "Not owner");
+        require(Blueprint(blueprintStorageProxy).getDeploymentOwner(agentRequestID) == sender, "Not owner");
 
-        Blueprint(blueprintCore).setCopyAgentFeeStorage(agentRequestID, tokenAddress, fee);
+        Blueprint(blueprintStorageProxy).setCopyAgentFeeStorage(agentRequestID, tokenAddress, fee);
         emit SetCopyAgentFee(agentRequestID, sender, tokenAddress, fee);
     }
 
     function setCopyAgentFeeWithSig(bytes32 agentRequestID, address tokenAddress, uint256 fee, bytes memory signature)
         external
     {
-        address owner = Blueprint(blueprintCore).getDeploymentOwner(agentRequestID);
+        address owner = Blueprint(blueprintStorageProxy).getDeploymentOwner(agentRequestID);
         require(owner != address(0), "Invalid agentRequestID");
         require(fee > 0, "Fee must be greater than 0");
-        require(Blueprint(blueprintCore).paymentAddressEnableMp(tokenAddress), "Invalid token address");
+        require(Blueprint(blueprintStorageProxy).paymentAddressEnableMp(tokenAddress), "Invalid token address");
 
-        uint256 nonce = Blueprint(blueprintCore).getUserNonce(owner);
-        bytes32 digest = Blueprint(blueprintCore).getSetCopyAgentFeeDigest(agentRequestID, tokenAddress, fee, nonce);
-        address signer = Blueprint(blueprintCore).getSignerAddress(digest, signature);
+        uint256 nonce = Blueprint(blueprintStorageProxy).getUserNonce(owner);
+        bytes32 digest =
+            Blueprint(blueprintStorageProxy).getSetCopyAgentFeeDigest(agentRequestID, tokenAddress, fee, nonce);
+        address signer = Blueprint(blueprintStorageProxy).getSignerAddress(digest, signature);
 
         require(signer == owner, "Wrong owner signature");
 
-        Blueprint(blueprintCore).setCopyAgentFeeStorage(agentRequestID, tokenAddress, fee);
-        Blueprint(blueprintCore).incrementUserNonce(owner);
+        Blueprint(blueprintStorageProxy).setCopyAgentFeeStorage(agentRequestID, tokenAddress, fee);
+        Blueprint(blueprintStorageProxy).incrementUserNonce(owner);
 
         emit SetCopyAgentFee(agentRequestID, owner, tokenAddress, fee);
     }
@@ -71,13 +78,14 @@ contract Agent is ERC2771Context {
         address tokenAddress,
         bytes memory signature
     ) public payable {
-        require(Blueprint(blueprintCore).paymentAddressEnableMp(tokenAddress), "Invalid token address");
+        require(Blueprint(blueprintStorageProxy).paymentAddressEnableMp(tokenAddress), "Invalid token address");
 
         // get digest
-        bytes32 digest =
-            Blueprint(blueprintCore).getCreateCopyAgentRequestDigest(copyID, originalAgentRequestID, tokenAddress);
+        bytes32 digest = Blueprint(blueprintStorageProxy).getCreateCopyAgentRequestDigest(
+            copyID, originalAgentRequestID, tokenAddress
+        );
         // get signer address
-        address signer = Blueprint(blueprintCore).getSignerAddress(digest, signature);
+        address signer = Blueprint(blueprintStorageProxy).getSignerAddress(digest, signature);
 
         // get signer address, notice signer cannot be owner of the original agent request
 
@@ -90,30 +98,34 @@ contract Agent is ERC2771Context {
         address tokenAddress,
         address userAddress
     ) internal {
-        require(Blueprint(blueprintCore).paymentAddressEnableMp(tokenAddress), "Invalid token address");
+        require(Blueprint(blueprintStorageProxy).paymentAddressEnableMp(tokenAddress), "Invalid token address");
 
-        address owner = Blueprint(blueprintCore).getDeploymentOwner(originalAgentRequestID);
+        address owner = Blueprint(blueprintStorageProxy).getDeploymentOwner(originalAgentRequestID);
         require(owner != address(0), "Invalid original agent request ID");
 
-        uint256 fee = Blueprint(blueprintCore).copyAgentFeeMp(originalAgentRequestID, tokenAddress);
+        uint256 fee = Blueprint(blueprintStorageProxy).copyAgentFeeMp(originalAgentRequestID, tokenAddress);
         require(fee > 0, "Copy Agent is not set by the owner");
 
         // check platformFee is set or not
-        require(Blueprint(blueprintCore).platformCopyAgentFee() > 0, "Platform fee is not set");
+        require(Blueprint(blueprintStorageProxy).platformCopyAgentFee() > 0, "Platform fee is not set");
 
         // calculate platform and creator fees
         uint256 platformFee =
-            (fee * Blueprint(blueprintCore).platformCopyAgentFee()) / Blueprint(blueprintCore).factor();
+            (fee * Blueprint(blueprintStorageProxy).platformCopyAgentFee()) / Blueprint(blueprintStorageProxy).factor();
 
         uint256 creatorFee = fee - platformFee;
 
-        address feeWallet = Blueprint(blueprintCore).feeCollectionWalletAddress();
-
+        address feeWallet = Blueprint(blueprintStorageProxy).feeCollectionWalletAddress();
+        address fromAddr = getPaymentFromAddress();
+        if (fromAddr != address(this)) {
+            // if the payment is not from the agent contract, we use the user address
+            fromAddr = userAddress;
+        }
         // pay the platform fee to the fee collection wallet
-        Blueprint(blueprintCore).forwardPayWithERC20(tokenAddress, platformFee, userAddress, feeWallet);
+        payWithERC20(tokenAddress, platformFee, fromAddr, feeWallet);
 
         // pay the creator fee to the owner of the original agent request
-        Blueprint(blueprintCore).forwardPayWithERC20(tokenAddress, creatorFee, userAddress, owner);
+        payWithERC20(tokenAddress, creatorFee, fromAddr, owner);
 
         emit CopyAgentRequest(copyID, originalAgentRequestID, userAddress);
     }
@@ -125,7 +137,8 @@ contract Agent is ERC2771Context {
         string memory serverURL,
         address tokenAddress
     ) public payable returns (bytes32 requestID) {
-        requestID = Blueprint(blueprintCore).createAgent(
+        //todo: migrate payment logic
+        requestID = Blueprint(blueprintStorageProxy).createAgent(
             _msgSender(), projectId, base64Proposal, privateWorkerAddress, serverURL, 0, tokenAddress
         );
     }
@@ -139,14 +152,15 @@ contract Agent is ERC2771Context {
         bytes memory signature
     ) public payable returns (bytes32 requestID) {
         // get EIP712 hash digest
-        bytes32 digest = Blueprint(blueprintCore).getCreateAgentWithTokenDigest(
+        bytes32 digest = Blueprint(blueprintStorageProxy).getCreateAgentWithTokenDigest(
             projectId, base64Proposal, serverURL, privateWorkerAddress, tokenAddress
         );
 
         // get signer address
-        address signerAddr = Blueprint(blueprintCore).getSignerAddress(digest, signature);
+        address signerAddr = Blueprint(blueprintStorageProxy).getSignerAddress(digest, signature);
 
-        requestID = Blueprint(blueprintCore).createAgent(
+        //todo: migrate payment logic
+        requestID = Blueprint(blueprintStorageProxy).createAgent(
             signerAddr, projectId, base64Proposal, privateWorkerAddress, serverURL, 0, tokenAddress
         );
     }
@@ -157,7 +171,8 @@ contract Agent is ERC2771Context {
         bytes32 requestID,
         string memory updatedBase64Config
     ) public payable {
-        Blueprint(blueprintCore).updateWorkerDeploymentConfigCommon(
+        //todo: migrate payment logic
+        Blueprint(blueprintStorageProxy).updateWorkerDeploymentConfigCommon(
             tokenAddress, _msgSender(), projectId, requestID, updatedBase64Config
         );
     }
@@ -169,36 +184,74 @@ contract Agent is ERC2771Context {
         string memory updatedBase64Config,
         bytes memory signature
     ) public payable {
-        address owner = Blueprint(blueprintCore).getDeploymentOwner(requestID);
+        address owner = Blueprint(blueprintStorageProxy).getDeploymentOwner(requestID);
         require(owner != address(0), "Invalid requestID");
 
         // get EIP712 hash digest
-        bytes32 digest = Blueprint(blueprintCore).getUpdateWorkerConfigDigest(
-            tokenAddress, projectId, requestID, updatedBase64Config, Blueprint(blueprintCore).getUserNonce(owner)
+        bytes32 digest = Blueprint(blueprintStorageProxy).getUpdateWorkerConfigDigest(
+            tokenAddress,
+            projectId,
+            requestID,
+            updatedBase64Config,
+            Blueprint(blueprintStorageProxy).getUserNonce(owner)
         );
 
         // get signer address
-        address signerAddr = Blueprint(blueprintCore).getSignerAddress(digest, signature);
+        address signerAddr = Blueprint(blueprintStorageProxy).getSignerAddress(digest, signature);
 
         // check if signer address is owner of requestID
         require(signerAddr == owner, "Invalid signature");
-
-        Blueprint(blueprintCore).updateWorkerDeploymentConfigCommon(
+        //todo: migrate payment logic
+        Blueprint(blueprintStorageProxy).updateWorkerDeploymentConfigCommon(
             tokenAddress, signerAddr, projectId, requestID, updatedBase64Config
         );
 
-        Blueprint(blueprintCore).incrementUserNonce(owner);
+        Blueprint(blueprintStorageProxy).incrementUserNonce(owner);
+    }
+
+    function topUp(address toUserAddress, address tokenAddress, uint256 amount) internal {
+        require(amount > 0, "Amount must be greater than 0");
+
+        require(Blueprint(blueprintStorageProxy).paymentAddressEnableMp(tokenAddress), "Payment address is not valid");
+
+        // update user top up
+        Blueprint(blueprintStorageProxy).AddUserTopUpAmount(toUserAddress, tokenAddress, amount);
+
+        address feeCollectionWalletAddress = Blueprint(blueprintStorageProxy).feeCollectionWalletAddress();
+
+        if (tokenAddress == address(0)) {
+            require(msg.value == amount, "Native token amount mismatch");
+
+            // payment to fee collection wallet address with ether
+            payWithNativeToken(payable(feeCollectionWalletAddress), amount);
+        } else {
+            // payment to feeCollectionWalletAddress with token, fromAddress always from msg.sender, either router or real user
+            payWithERC20(tokenAddress, amount, getPaymentFromAddress(), feeCollectionWalletAddress);
+        }
+    }
+
+    function getPaymentFromAddress() internal view returns (address) {
+        // payment goes to router and router transfer fund into agent contract and then agent contract process from here
+        // if the sender is the trust router, we use the agent contract address as the from address
+        // otherwise, we use the real user address
+        return (msg.sender == trustRouter) ? address(this) : _msgSender();
     }
 
     function userTopUp(address tokenAddress, uint256 amount) public payable {
-        Blueprint(blueprintCore).topUp(msg.sender, tokenAddress, amount);
-        address feeCollectionWalletAddress = Blueprint(blueprintCore).feeCollectionWalletAddress();
-        emit UserTopUp(msg.sender, feeCollectionWalletAddress, tokenAddress, amount);
+        topUp(_msgSender(), tokenAddress, amount);
+        emit UserTopUp(
+            _msgSender(), Blueprint(blueprintStorageProxy).feeCollectionWalletAddress(), tokenAddress, amount
+        );
     }
 
     function userTopUpOther(address userAddress, address tokenAddress, uint256 amount) public payable {
-        Blueprint(blueprintCore).topUp(userAddress, tokenAddress, amount);
-        address feeCollectionWalletAddress = Blueprint(blueprintCore).feeCollectionWalletAddress();
-        emit UserTopUpOther(msg.sender, userAddress, feeCollectionWalletAddress, tokenAddress, amount);
+        topUp(userAddress, tokenAddress, amount);
+        emit UserTopUpOther(
+            _msgSender(),
+            userAddress,
+            Blueprint(blueprintStorageProxy).feeCollectionWalletAddress(),
+            tokenAddress,
+            amount
+        );
     }
 }

src/Blueprint.sol

@@ -15,6 +15,7 @@ contract Blueprint is Initializable, OwnableUpgradeable, BlueprintCore {
     event UpdateWorker(address workerAddress, bool isTrusted);
     event CreditReward(address indexed userAddress, uint256 amount);
     event SetGlobalPlatformFee(uint256 fee, uint256 factor);
+    event SetAdminContract(address agentContract);
 
     modifier isAdmin() {
         // slither-disable-next-line timestamp
@@ -129,8 +130,10 @@ contract Blueprint is Initializable, OwnableUpgradeable, BlueprintCore {
         emit CreditReward(userAddress, amount);
     }
 
-    function setAgentContract(address _agent) public onlyOwner {
-        agentContract = _agent;
+    function setAdminContract(address _adminContract) public onlyOwner {
+        require(_adminContract != address(0), "Admin contract address is invalid");
+        adminContracts[_adminContract] = true;
+        emit SetAdminContract(_adminContract);
     }
 
     // 6 %。=  6 / 100  means fee =6 and baseFactor = 100