Added A3A token to serve as fee for prompts

Author: Axel Valavaara

script/DeployOrderContract.s.sol

@@ -6,18 +6,23 @@ pragma solidity ^0.8.18;
 import {OrderContract} from "../src/OrderContract.sol";
 import {Script} from "forge-std/Script.sol";
 import {HelperConfig} from "./HelperConfig.s.sol";
-
+import {A3AToken} from "../src/A3Atoken.sol";
 contract DeployOrderContract is Script {
 
 
-    function run() public returns (OrderContract, HelperConfig) {
+    function run() public returns (OrderContract, HelperConfig, A3AToken) {
         HelperConfig helperConfig = new HelperConfig();
+        
         (address pyUSD, address agentController, uint256 deployerKey )= helperConfig.activeNetworkConfig();
+        
         vm.startBroadcast(deployerKey);
+        A3AToken token = new A3AToken();
         OrderContract orderContract = new OrderContract(
-        agentController,  pyUSD // Replace with actual pyUSD token address
+        agentController,  pyUSD, address(token) // Replace with actual pyUSD token address
         );
+        token.transferOwnership(address(orderContract));
+        
         vm.stopBroadcast();
-        return (orderContract, helperConfig);
+        return (orderContract, helperConfig, token);
     }
 }

src/A3Atoken.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+
+// Layout of Contract:
+// version
+// imports
+// errors
+// interfaces, libraries, contracts
+// Type declarations
+// State variables
+// Events
+// Modifiers
+// Functions
+
+// Layout of Functions:
+// constructor
+// receive function (if exists)
+// fallback function (if exists)
+// external
+// public
+// internal
+// private
+// view & pure functions
+
+pragma solidity ^0.8.18;
+
+import {ERC20Burnable, ERC20} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+
+
+contract A3AToken is ERC20Burnable, Ownable {
+    /* Erors */
+    error A3AToken__BurnAmountMustBeMoreThanZero();
+    error A3AToken__BurnAmountMustBeMoreThanBalance();
+    error A3AToken__MintToTheZeroAddress();
+    error A3AToken__MintAmountMustBeMoreThanZero();
+
+    constructor() ERC20("Decentralized Stable Coin", "DSC") Ownable(msg.sender) {}
+
+    function burn(uint256 _amount) public override onlyOwner {
+        uint256 balance = balanceOf(msg.sender);
+
+        if (_amount <= 0) {
+            revert A3AToken__BurnAmountMustBeMoreThanZero();
+        }
+        if (balance < _amount) {
+            revert A3AToken__BurnAmountMustBeMoreThanBalance();
+        }
+        super.burn(_amount);
+    }
+
+    function mint(address _to, uint256 _amount) external onlyOwner returns (bool) {
+        if (_to == address(0)) {
+            revert A3AToken__MintToTheZeroAddress();
+        }
+        if (_amount <= 0) {
+            revert A3AToken__MintAmountMustBeMoreThanZero();
+        }
+        _mint(_to, _amount);
+        return true;
+    }
+}

src/OrderContract.sol

@@ -25,6 +25,7 @@ pragma solidity ^0.8.18;
 
 import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+import {A3AToken} from "./A3Atoken.sol";
 
 contract OrderContract is ReentrancyGuard{
     /* errors */
@@ -57,11 +58,13 @@ contract OrderContract is ReentrancyGuard{
         OrderStatus status;
     }
     /* state variables */
-    uint256 private constant AGENT_FEE = 1 ether; // Fee for agent services. Adjust as needed.
+    uint256 private constant ADDITIONAL_PRECISION = 1e12; // To handle decimals for tokens with less than 18 decimals
+    uint256 private constant AGENT_FEE = 1e6; // Fee for agent services. Adjust as needed.
     uint256 private constant HOLD_UNTIL = 600; // Time in seconds to hold the order. Adjust as needed.
     uint64 private offerID = 0; // Counter for offer IDs
     address private immutable agentController; // Address of the agent controller
     address private immutable pyUSD; // Address of the pyUSD token contract
+    address private immutable a3aToken; // Address of the A3A token contract
 
     // will make mappings to struct!!! thus too messy.
     //////////////////////////////////////////////
@@ -104,10 +107,11 @@ contract OrderContract is ReentrancyGuard{
         _;
 
     }
-    constructor(address agentControllerAddress, address pyUSDAddress) {
+    constructor(address agentControllerAddress, address pyUSDAddress, address a3aTokenAddress) {
         // Initialization logic if needed
         agentController = agentControllerAddress;
         pyUSD = pyUSDAddress;
+        a3aToken = a3aTokenAddress;
     }
     function proposeOrder(bytes32 promptHash) external returns(uint64 offerId) {
 
@@ -125,12 +129,23 @@ contract OrderContract is ReentrancyGuard{
 
         // addressToOfferIdToPromptHash[msg.sender][offerID] = promptHash;
         // offerIdToUser[offerID] = msg.sender;
+
         emit OrderProposed(offers[offerID].buyer, offerID, offers[offerID].promptHash);
-        
+        // Burn 10 A3A tokens from uses. This acts as Fee for using the platform.
+        _burnA3A(10 ether, msg.sender);
         return offerID;
 
     }
 
+    function _burnA3A(uint256 amount,address A3AFrom) private {
+        
+        bool success = A3AToken(a3aToken).transferFrom(A3AFrom, address(this), amount);
+        if (!success) {
+            revert OrderContract__ERC20TransferFailed();
+        }
+        A3AToken(a3aToken).burn(amount);
+    }
+
 
 
     function confirmOrder(uint64 offerId) external nonReentrant onlyUserWithOffer(offerId) {
@@ -203,6 +218,16 @@ contract OrderContract is ReentrancyGuard{
     }
 
 
+    function buyA3AToken(uint256 PyUsdAmount) external nonReentrant {
+
+        bool success = ERC20(pyUSD).transferFrom(msg.sender, address(this), PyUsdAmount);
+        if (!success) {
+            revert OrderContract__ERC20TransferFailed();
+        }
+        A3AToken(a3aToken).mint(msg.sender, (PyUsdAmount*ADDITIONAL_PRECISION)*10);
+    }
+
+
 
     /* getter functions */
     function getPromptHash(uint64 offerId) external view returns (bytes32) {
@@ -334,5 +359,4 @@ contract OrderContract is ReentrancyGuard{
     }
 
 
-
-}
+}

test/fuzz/InvariantsTest.t.sol

@@ -16,7 +16,7 @@ contract InvariantsTest is StdInvariant, Test {
 
     function setUp() public {
         DeployOrderContract deployer = new DeployOrderContract();
-        (orderContract, helperConfig) = deployer.run();
+        (orderContract, helperConfig,) = deployer.run();
         targetContract(address(orderContract));
     }
 

test/unit/OrderContractTest.t.sol

@@ -7,17 +7,20 @@ import {OrderContract} from "../../src/OrderContract.sol";
 import {HelperConfig} from "script/HelperConfig.s.sol";
 import {DeployOrderContract} from "script/DeployOrderContract.s.sol";
 import {ERC20Mock} from "@openzeppelin/contracts/mocks/token/ERC20Mock.sol";
+import {A3AToken} from "../../src/A3Atoken.sol";
 
 contract OrderContractTest is Test {
     OrderContract orderContract;
     HelperConfig helperConfig;
     address pyUSD;
     address addressController;
+    A3AToken a3aToken;
 
     uint256 constant amountForCompute = 10 ether;
     bytes32 constant promptHash = keccak256(abi.encodePacked("Test Prompt"));
 
     address public USER = makeAddr("user");
+    address public USER2 = makeAddr("user2");
     address public SELLER = makeAddr("seller");
 
     event OrderProposed(address indexed user, uint64 indexed offerId, bytes32 indexed promptHash);
@@ -26,14 +29,45 @@ contract OrderContractTest is Test {
 
     function setUp() public {
         DeployOrderContract deployer = new DeployOrderContract();
-        (orderContract, helperConfig) = deployer.run();
+        (orderContract, helperConfig, a3aToken) = deployer.run();
         (pyUSD, addressController, ) = helperConfig.activeNetworkConfig();
         ERC20Mock(pyUSD).mint(USER, 100 ether);
+        ERC20Mock(pyUSD).mint(USER2, 100 ether);
+
+        // approve the orderContract to spend USERs A3A tokens so no need to approve every time in tests
+        vm.prank(USER);
+        a3aToken.approve(address(orderContract), type(uint256).max);
+        // buy A3A tokens for USER so tests work
+        vm.startPrank(USER);
+        ERC20Mock(pyUSD).approve(address(orderContract), 10e6);
+        orderContract.buyA3AToken(10e6);
+        vm.stopPrank();
+        
+
 
+    }
+      //////////////////////////////////////
+    //        Buy A3A tests               //
+    //////////////////////////////////////
+    function testBuyA3AToken() public {
+        
+        // Arrange
+        uint256 amountToBuy = 10e6;
+        uint256 expectedBalanceOfA3A = 100 ether;
+        // Act
+        vm.startPrank(USER2);
+        ERC20Mock(pyUSD).approve(address(orderContract), amountToBuy);
+        orderContract.buyA3AToken(amountToBuy);
+        vm.stopPrank();
+        // Assert
+        uint256 userBalanceAfter = a3aToken.balanceOf(USER2);
+        assertEq(userBalanceAfter, expectedBalanceOfA3A);
+
     }
      //////////////////////////////////////
     //        proposeOrder tests          //
     //////////////////////////////////////
+
     function testProposeOrderUpdatesVariables() public {
 
 
@@ -239,7 +273,7 @@ contract OrderContractTest is Test {
 
     function testGetAgentFee() public view {
         // Arrange
-        uint256 expectedAgentFee = 1 ether; // AGENT_FEE is set to 1 ether in the contract
+        uint256 expectedAgentFee = 1e6; // AGENT_FEE is set to 1 ether in the contract
         // Act
         uint256 agentFee = orderContract.getAgentFee();
         // Assert