Minting A3A and PyUsd for local testing. Added getA3ATokenAddress getter. Removed unnecessary data looping

Author: Axel Valavaara

makefile

@@ -1,4 +1,4 @@
 -include .env
 .PHONY: all test deploy
 
-deploy :; forge script script/DeployOrderContract.s.sol:DeployOrderContract --rpc-url http://127.0.0.1:8545 
+deploy :; forge script script/DeployOrderContract.s.sol:DeployOrderContract --rpc-url 127.0.0.1:8545 --broadcast --private-key $(DEFAULT_ANVIL_KEY) -vvvv

script/DeployOrderContract.s.sol

@@ -20,7 +20,14 @@ contract DeployOrderContract is Script {
         OrderContract orderContract = new OrderContract(
         agentController,  pyUSD, address(token) // Replace with actual pyUSD token address
         );
+        if (block.chainid == 31337) {
+            
+            token.mint(vm.envAddress("PUBLIC_KEY"), 1000000 ether);
+            
+        }
         token.transferOwnership(address(orderContract));
+
+        
 
         vm.stopBroadcast();
         return (orderContract, helperConfig, token);

script/HelperConfig.s.sol

@@ -5,6 +5,7 @@ pragma solidity ^0.8.18;
 
 import {Script} from  "forge-std/Script.sol";
 import {ERC20Mock} from "@openzeppelin/contracts/mocks/token/ERC20Mock.sol";
+
 contract HelperConfig is Script {
 
     struct NetworkConfig {
@@ -29,12 +30,13 @@ contract HelperConfig is Script {
         }
         vm.startBroadcast();
         ERC20Mock pyUSD = new ERC20Mock();
+        pyUSD.mint(vm.envAddress("PUBLIC_KEY"), 100 ether);
 
         vm.stopBroadcast();
         return NetworkConfig({
             pyUSD: address(pyUSD),
             agentController: address(5),
-            deployerKey: vm.envUint("PRIVATE_KEY")
+            deployerKey: vm.envUint("DEFAULT_ANVIL_KEY")
         });
 
 }

src/A3Atoken.sol

@@ -34,7 +34,7 @@ contract A3AToken is ERC20Burnable, Ownable {
     error A3AToken__MintToTheZeroAddress();
     error A3AToken__MintAmountMustBeMoreThanZero();
 
-    constructor() ERC20("Decentralized Stable Coin", "DSC") Ownable(msg.sender) {}
+    constructor() ERC20("A3A Token", "A3A") Ownable(msg.sender) {}
 
     function burn(uint256 _amount) public override onlyOwner {
         uint256 balance = balanceOf(msg.sender);

src/OrderContract.sol

@@ -67,21 +67,10 @@ contract OrderContract is ReentrancyGuard{
     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.
-    //////////////////////////////////////////////
-    //  FIX THIS!!!!
-    ///////////////////////////////////
-    // mapping(address => mapping(uint64 offerId => bytes32 promptHash)) private addressToOfferIdToPromptHash;
-    // mapping(uint64 offerId => uint256 timestamp) private offerIdToTimestamp;
-    // mapping(uint64 offerId => mapping(address user => uint256 amountPaid)) private offerIdToUserToAmountPaid;
-    // mapping(uint64 offerId => OrderStatus status) private offerIdToStatus;
-    // mapping(uint64 offerId => bytes32 answerHash) private offerIdToAnswerHash;
-    // mapping(uint64 => address) private offerIdToUser;
 
     mapping(uint64 => Offer) public offers;
 
-    // User order tracking mappings
-    mapping(address => mapping(uint64 => bool)) private userOrders;
+   
     mapping(address => uint64[]) private userOrderIds;
 
     // merchants address->orderIds mapping to fetch all orders for a merchant
@@ -125,11 +114,9 @@ contract OrderContract is ReentrancyGuard{
         offers[offerID].promptHash = promptHash;
 
         // Update user order mappings
-        userOrders[userWalletAddress][offerID] = true;
+       
         userOrderIds[userWalletAddress].push(offerID);
-        
-        // 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.
@@ -155,12 +142,10 @@ contract OrderContract is ReentrancyGuard{
         }
         // update amount paid for the offer by the user
         uint256 amountToPay = offers[offerId].price + AGENT_FEE;
-        // offerIdToUserToAmountPaid[offerId][msg.sender] += amountToPay;
-        // offerIdToStatus[offerId] = OrderStatus.Confirmed;
+    
         offers[offerId].paid = amountToPay;
         offers[offerId].status = OrderStatus.Confirmed;
-        // Record the current timestamp for the offer
-        // offerIdToTimestamp[offerId] = block.timestamp;
+       
         offers[offerId].timestamp = block.timestamp;
         bool success= ERC20(pyUSD).transferFrom(msg.sender, address(this), amountToPay);
 
@@ -277,6 +262,10 @@ contract OrderContract is ReentrancyGuard{
         return offers[orderId];
     }
 
+    function getA3ATokenAddress() external view returns (address) {
+        return a3aToken;
+    }
+
     // User order query functions for backend integration
 
     /**
@@ -294,8 +283,12 @@ contract OrderContract is ReentrancyGuard{
      * @param orderId The order ID to check
      * @return bool indicating if the user has this order
      */
-    function hasUserOrder(address user, uint64 orderId) external view returns (bool) {
-        return userOrders[user][orderId];
+    function hasUserOrder(address user, uint64 orderId) public view returns (bool) {
+        if (offers[orderId].buyer == user) {
+            return true;
+        } else {
+            return false;
+        }
     }
 
     /**
@@ -311,23 +304,8 @@ contract OrderContract is ReentrancyGuard{
         // require(userOrders[user][orderId], "Order does not belong to user");
         return offers[orderId].status;
     }
+  
 
-    /**
-     * @notice Get all orders with their statuses for a specific user
-     * @param user The user address to query
-     * @return orderIds Array of order IDs
-     * @return statuses Array of corresponding order statuses
-     */
-    function getUserOrdersWithStatus(address user) external view returns (uint64[] memory orderIds, OrderStatus[] memory statuses) {
-        uint64[] memory userIds = userOrderIds[user];
-        OrderStatus[] memory orderStatuses = new OrderStatus[](userIds.length);
-        
-        for (uint256 i = 0; i < userIds.length; i++) {
-            orderStatuses[i] = offers[userIds[i]].status;
-        }
-        
-        return (userIds, orderStatuses);
-    }
 
     /**
      * @notice Get complete order details for a user's specific order
@@ -336,36 +314,14 @@ contract OrderContract is ReentrancyGuard{
      * @return Complete Offer struct for the specified order
      */
     function getUserOrderDetails(address user, uint64 orderId) external view returns (Offer memory) {
-        require(userOrders[user][orderId], "Order does not belong to user");
+        if (hasUserOrder(user, orderId) == false) {
+            revert OrderContract__userHasNoAccessToOffer();
+        }
         return offers[orderId];
     }
 
-    /**
-     * @notice Get orders filtered by status for a user
-     * @param user The user address
-     * @param status The status to filter by
-     * @return Array of order IDs matching the specified status
-     */
-    function getUserOrdersByStatus(address user, OrderStatus status) external view returns (uint64[] memory) {
-        uint64[] memory userIds = userOrderIds[user];
-        uint64[] memory filteredIds = new uint64[](userIds.length);
-        uint256 count = 0;
-        
-        for (uint256 i = 0; i < userIds.length; i++) {
-            if (offers[userIds[i]].status == status) {
-                filteredIds[count] = userIds[i];
-                count++;
-            }
-        }
-        
-        // Create a properly sized array
-        uint64[] memory result = new uint64[](count);
-        for (uint256 i = 0; i < count; i++) {
-            result[i] = filteredIds[i];
-        }
-        
-        return result;
-    }
+   
+   
 
 
 }

test/unit/OrderContractTest.t.sol

@@ -372,29 +372,7 @@ contract OrderContractTest is Test {
         assertEq(uint8(status), uint8(OrderContract.OrderStatus.InProgress));
     }
 
-    function testGetUserOrdersWithStatus() public {
-        // Arrange
-        bytes32 testPromptHash1 = keccak256(abi.encodePacked("Test Prompt 1"));
-        bytes32 testPromptHash2 = keccak256(abi.encodePacked("Test Prompt 2"));
-        
-        vm.prank(USER);
-        ERC20Mock(pyUSD).approve(address(orderContract), amountForCompute * 2);
-        vm.startPrank(addressController);
-        uint64 offerId1 = orderContract.proposeOrder(testPromptHash1, USER);
-        uint64 offerId2 = orderContract.proposeOrder(testPromptHash2, USER);
-        vm.stopPrank();
-        
-        // Act
-        (uint64[] memory orderIds, OrderContract.OrderStatus[] memory statuses) = orderContract.getUserOrdersWithStatus(USER);
-        
-        // Assert
-        assertEq(orderIds.length, 2);
-        assertEq(statuses.length, 2);
-        assertEq(orderIds[0], offerId1);
-        assertEq(orderIds[1], offerId2);
-        assertEq(uint8(statuses[0]), uint8(OrderContract.OrderStatus.InProgress));
-        assertEq(uint8(statuses[1]), uint8(OrderContract.OrderStatus.InProgress));
-    }
+    
 
     function testGetUserOrderDetails() public {
         // Arrange
@@ -415,34 +393,9 @@ contract OrderContractTest is Test {
         assertEq(uint8(offer.status), uint8(OrderContract.OrderStatus.InProgress));
     }
 
-    function testGetUserOrdersByStatus() public proposeOrderForUser {
-        // Arrange - we already have one order in InProgress from the modifier
-        uint64 initialOfferId = 1;
-        
-        // Propose answer to move to Proposed status
-        vm.prank(addressController);
-        orderContract.proposeOrderAnswer(keccak256(abi.encodePacked("Test Answer")), initialOfferId, 5 ether, SELLER);
-        
-        // Create another order that stays InProgress
-        bytes32 testPromptHash2 = keccak256(abi.encodePacked("Test Prompt 2"));
-        vm.prank(USER);
-        ERC20Mock(pyUSD).approve(address(orderContract), amountForCompute);
-        vm.startPrank(addressController);
-        uint64 offerId2 = orderContract.proposeOrder(testPromptHash2, USER);
-        vm.stopPrank();
-        
-        // Act
-        uint64[] memory proposedOrders = orderContract.getUserOrdersByStatus(USER, OrderContract.OrderStatus.Proposed);
-        uint64[] memory inProgressOrders = orderContract.getUserOrdersByStatus(USER, OrderContract.OrderStatus.InProgress);
-        
-        // Assert
-        assertEq(proposedOrders.length, 1);
-        assertEq(proposedOrders[0], initialOfferId);
-        assertEq(inProgressOrders.length, 1);
-        assertEq(inProgressOrders[0], offerId2);
-    }
+  
 
-    function testHasUserOrderReturnsFalseForNonExistentOrder() public {
+    function testHasUserOrderReturnsFalseForNonExistentOrder() public view {
         // Act & Assert
         assertFalse(orderContract.hasUserOrder(USER, 999));
     }
@@ -462,4 +415,26 @@ contract OrderContractTest is Test {
         orderContract.getUserOrderStatus(otherUser, offerId);
     }
 
+    function testUserGetsMintedBalance() public view {
+        // Arrange
+        uint256 expectedBalance = 1000000 ether; // 10e6 pyUSD buys 100 A3A tokens
+        
+        // Act
+        uint256 userBalance = a3aToken.balanceOf(vm.envAddress("PUBLIC_KEY"));
+        
+        // Assert
+        assertEq(userBalance, expectedBalance);
+    }
+    
+    function testUserGetsMintedPyUsd() public view {
+        // Arrange
+        uint256 expectedBalance = 100 ether; // Anvil setup mints 100 pyUSD to PUBLIC_KEY
+        
+        // Act
+        uint256 userBalance = ERC20Mock(pyUSD).balanceOf(vm.envAddress("PUBLIC_KEY"));
+        
+        // Assert
+        assertEq(userBalance, expectedBalance);
+    }
+
 }